Mercurial > pub > RazorEngine
changeset 0:5bca2d201ad8
initial commit
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/README.markdown Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,7 @@ +RazorEngine +=========== + +A templating engine built on Microsoft's Razor parsing engine, RazorEngine allows you to use Razor syntax to build dynamic templates: + + string template = "Hello @Model.Name, welcome to RazorEngine!"; + string result = Razor.Parse(template, new { Name = "World" }); \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/AttributeValue.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,38 @@ +namespace RazorEngine +{ + using System; + + public class AttributeValue + { + public AttributeValue(PositionTagged<string> prefix, PositionTagged<object> value, bool literal) + { + Prefix = prefix; + Value = value; + Literal = literal; + } + + public PositionTagged<string> Prefix { get; private set; } + public PositionTagged<object> Value { get; private set; } + public bool Literal { get; private set; } + + public static AttributeValue FromTuple(Tuple<Tuple<string, int>, Tuple<object, int>, bool> value) + { + return new AttributeValue(value.Item1, value.Item2, value.Item3); + } + + public static AttributeValue FromTuple(Tuple<Tuple<string, int>, Tuple<string, int>, bool> value) + { + return new AttributeValue(value.Item1, new PositionTagged<object>(value.Item2.Item1, value.Item2.Item2), value.Item3); + } + + public static implicit operator AttributeValue(Tuple<Tuple<string, int>, Tuple<object, int>, bool> value) + { + return FromTuple(value); + } + + public static implicit operator AttributeValue(Tuple<Tuple<string, int>, Tuple<string, int>, bool> value) + { + return FromTuple(value); + } + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/ClassDiagram.cd Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,395 @@ +<?xml version="1.0" encoding="utf-8"?> +<ClassDiagram MajorVersion="1" MinorVersion="1" MembersFormat="FullSignature"> + <Class Name="RazorEngine.Compilation.CompilerServiceBase" Collapsed="true"> + <Position X="4.5" Y="0.5" Width="1.75" /> + <TypeIdentifier> + <HashCode>AAAAAAAABCAAAAAAAAEgAAAAQAAgCMAAAAAAAAAAAQA=</HashCode> + <FileName>Compilation\CompilerServiceBase.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" /> + </Class> + <Class Name="RazorEngine.Compilation.CompilerServiceBuilder" Collapsed="true"> + <Position X="10.5" Y="0.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAIAAAAIAEAAAAAQAAAAAAAAAAAACAAAAAAA=</HashCode> + <FileName>Compilation\CompilerServiceBuilder.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.CompilerServicesUtility" Collapsed="true"> + <Position X="12.25" Y="0.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAJBAAAABAAAAAAAAAAAAAAIAAAEBAA=</HashCode> + <FileName>Compilation\CompilerServicesUtility.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.DefaultCompilerServiceFactory" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="10.5" Y="1.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAA=</HashCode> + <FileName>Compilation\DefaultCompilerServiceFactory.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Compilation.DirectCompilerServiceBase" Collapsed="true"> + <Position X="4.25" Y="2" Width="2" /> + <TypeIdentifier> + <HashCode>QAIAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA=</HashCode> + <FileName>Compilation\DirectCompilerServiceBase.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" /> + </Class> + <Class Name="RazorEngine.Compilation.HasDynamicModelAttribute" Collapsed="true"> + <Position X="12.25" Y="2.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\HasDynamicModelAttribute.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.RazorDynamicObject" Collapsed="true"> + <Position X="14" Y="3.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAgAAAAAAAA=</HashCode> + <FileName>Compilation\RazorDynamicObject.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.TypeContext" Collapsed="true"> + <Position X="17.5" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAEAAACEAAAAABAAAAAAAAAAAAAAAAIAAAAAAAA=</HashCode> + <FileName>Compilation\TypeContext.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.CSharp.CSharpDirectCompilerService" Collapsed="true"> + <Position X="2.75" Y="3.25" Width="2.25" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAgAAAAQAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\CSharp\CSharpDirectCompilerService.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.CSharp.CSharpRazorCodeGenerator" Collapsed="true"> + <Position X="14" Y="0.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAQAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\CSharp\CSharpRazorCodeGenerator.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.CSharp.CSharpRazorCodeLanguage" Collapsed="true"> + <Position X="15.75" Y="0.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAQAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\CSharp\CSharpRazorCodeLanguage.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.VisualBasic.VBDirectCompilerService" Collapsed="true"> + <Position X="5.75" Y="3.25" Width="2" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\VisualBasic\VBDirectCompilerService.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.VisualBasic.VBRazorCodeGenerator" Collapsed="true"> + <Position X="10.5" Y="5.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAQAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\VisualBasic\VBRazorCodeGenerator.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Compilation.VisualBasic.VBRazorCodeLanguage" Collapsed="true"> + <Position X="12.25" Y="5.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAQAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\VisualBasic\VBRazorCodeLanguage.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Configuration.DefaultTemplateServiceConfiguration" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="14" Y="1.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAEACAAAAAAIAAAAAEAAEAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Configuration\DefaultTemplateServiceConfiguration.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Configuration.FluentConfigurationBuilder" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="8.75" Y="2.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>gAAIARAAAAAAAAQAAAAAAAEBAgAAAQAAAAAACAAAAAA=</HashCode> + <FileName>Configuration\Fluent\FluentConfigurationBuilder.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Configuration.FluentTemplateServiceConfiguration" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="10.5" Y="2.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAEACAAAAAAIAAAAAFAAEAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Configuration\Fluent\FluentTemplateServiceConfiguration.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Configuration.RazorEngineConfigurationSection" Collapsed="true"> + <Position X="15.75" Y="3.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>ACAAAAAAAAAAAAAAAAAIBAAAAAABAABAgCAAAAABAAA=</HashCode> + <FileName>Configuration\RazorEngineConfigurationSection.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.CachedTemplateItem" Collapsed="true"> + <Position X="8.75" Y="0.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAIAAAAAAAA=</HashCode> + <FileName>Templating\CachedTemplateItem.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.DefaultActivator" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="17.5" Y="0.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\DefaultActivator.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Templating.DefaultAppDomainFactory" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="8.75" Y="1.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAA=</HashCode> + <FileName>Templating\DefaultAppDomainFactory.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Templating.DelegateActivator" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="15.75" Y="1.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAABAAAAAQAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\DelegateActivator.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Templating.DelegateAppDomainFactory" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="17.5" Y="1.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASAAAAAAA=</HashCode> + <FileName>Templating\DelegateAppDomainFactory.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Templating.InstanceContext" Collapsed="true"> + <Position X="17.5" Y="2.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAA=</HashCode> + <FileName>Templating\InstanceContext.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.IsolatedTemplateService" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="8.75" Y="3.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAIkAAAAACAAAAQAAAAAAAQEAAAEAgAAAEAYAAARAAA=</HashCode> + <FileName>Templating\IsolatedTemplateService.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Templating.RequireNamespacesAttribute" Collapsed="true"> + <Position X="17.5" Y="3.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\RequireNamespacesAttribute.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.TemplateBase" Collapsed="true"> + <Position X="2.75" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AIAAAAAAAAABCAQAAAAAAAwAAAAAAAAgCAAAAAGACAA=</HashCode> + <FileName>Templating\TemplateBase.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" /> + </Class> + <Class Name="RazorEngine.Templating.TemplateBase<T>" Collapsed="true"> + <Position X="2.75" Y="6" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAI=</HashCode> + <FileName>Templating\TemplateBaseOfT.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" /> + </Class> + <Class Name="RazorEngine.Templating.TemplateCompilationException" Collapsed="true"> + <Position X="8.75" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAQAAAAAAAAAgAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\TemplateCompilationException.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.TemplateParsingException" Collapsed="true"> + <Position X="10.5" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAABAAAAgAAAAAAAAAAAAAAABAAA=</HashCode> + <FileName>Templating\TemplateParsingException.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.TemplateService" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="12.25" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>EIIoAAgACKAAAAQIAAAAAAQAQAAEAgAAAEAkAAABAAA=</HashCode> + <FileName>Templating\TemplateService.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Templating.TemplateServiceFactory" Collapsed="true"> + <Position X="14" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAgAAAAAAAAAA=</HashCode> + <FileName>Templating\TemplateServiceFactory.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.TemplateWriter" Collapsed="true"> + <Position X="15.75" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\TemplateWriter.cs</FileName> + </TypeIdentifier> + </Class> + <Class Name="RazorEngine.Templating.TypeLoader" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="8.75" Y="5.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>EAIEBAAQACABAAAAAAAQBAABAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\TypeLoader.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Templating.Parallel.DefaultParallelQueryPlan<T>" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="12.25" Y="1.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\Parallel\DefaultParallelQueryPlan.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Text.HtmlEncodedString" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="14" Y="2.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>EAAAAACAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Text\HtmlEncodedString.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Text.HtmlEncodedStringFactory" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="15.75" Y="2.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Text\HtmlEncodedStringFactory.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Text.RawString" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="10.5" Y="3.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAACAAAAAAAAEAAAAAAAAAAAAAAAAAAQAAAAAAAA=</HashCode> + <FileName>Text\RawString.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Class Name="RazorEngine.Text.RawStringFactory" Collapsed="true" BaseTypeListCollapsed="true"> + <Position X="12.25" Y="3.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Text\RawStringFactory.cs</FileName> + </TypeIdentifier> + <Lollipop Position="0.2" Collapsed="true" /> + </Class> + <Interface Name="RazorEngine.Compilation.ICompilerService" Collapsed="true"> + <Position X="12.25" Y="6.75" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAABCAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Compilation\ICompilerService.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Compilation.ICompilerServiceFactory" Collapsed="true"> + <Position X="14" Y="6.75" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAA=</HashCode> + <FileName>Compilation\ICompilerServiceFactory.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Configuration.IConfigurationBuilder" Collapsed="true"> + <Position X="15.75" Y="6.75" Width="1.5" /> + <TypeIdentifier> + <HashCode>gAAAARAAAAAAAAQAAAAAAAEBAgAAAQAAAAAACAAAAAA=</HashCode> + <FileName>Configuration\Fluent\IConfigurationBuilder.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Configuration.ITemplateServiceConfiguration" Collapsed="true"> + <Position X="14" Y="7.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAEACAAAAAAIAAAAAEAAEAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Configuration\ITemplateServiceConfiguration.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Templating.IActivator" Collapsed="true"> + <Position X="8.75" Y="6.75" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\IActivator.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Templating.IAppDomainFactory" Collapsed="true"> + <Position X="10.5" Y="6.75" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAA=</HashCode> + <FileName>Templating\IAppDomainFactory.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Templating.ITemplate" Collapsed="true"> + <Position X="5.75" Y="4.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAABAAQAAAAAAAQAAAAAAAAAAAAAAAGAAAI=</HashCode> + <FileName>Templating\ITemplate.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Templating.ITemplate<T>" Collapsed="true"> + <Position X="5.75" Y="5.75" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAA=</HashCode> + <FileName>Templating\ITemplateOfT.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Templating.ITemplateService" Collapsed="true"> + <Position X="12.25" Y="7.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAgAAAAAAAAAAQIAAAAAAQAAAAEAgAAAEAAAAABAAA=</HashCode> + <FileName>Templating\ITemplateService.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Templating.Parallel.IParallelQueryPlan<T>" Collapsed="true"> + <Position X="10.5" Y="7.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Templating\Parallel\IParallelQueryPlan.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Text.IEncodedString" Collapsed="true"> + <Position X="17.5" Y="6.75" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Text\IEncodedString.cs</FileName> + </TypeIdentifier> + </Interface> + <Interface Name="RazorEngine.Text.IEncodedStringFactory" Collapsed="true"> + <Position X="8.75" Y="7.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Text\IEncodedStringFactory.cs</FileName> + </TypeIdentifier> + </Interface> + <Enum Name="RazorEngine.Encoding" Collapsed="true"> + <Position X="8.75" Y="8.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAAAAA=</HashCode> + <FileName>Encoding.cs</FileName> + </TypeIdentifier> + </Enum> + <Enum Name="RazorEngine.Language" Collapsed="true"> + <Position X="10.5" Y="8.5" Width="1.5" /> + <TypeIdentifier> + <HashCode>AAAACAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAA=</HashCode> + <FileName>Language.cs</FileName> + </TypeIdentifier> + </Enum> + <Font Name="Tahoma" Size="8.25" /> +</ClassDiagram> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/CodeGenerators/SetModelTypeCodeGenerator.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,48 @@ +namespace RazorEngine.CodeGenerators +{ + using System; + using System.Globalization; + using System.Web.Razor.Generator; + using Common; + + internal class SetModelTypeCodeGenerator : SetBaseTypeCodeGenerator + { + private readonly string _genericTypeFormat; + + public SetModelTypeCodeGenerator(string modelType, string genericTypeFormat) + : base(modelType) + { + _genericTypeFormat = genericTypeFormat; + } + + protected override string ResolveType(CodeGeneratorContext context, string baseType) + { + return String.Format( + CultureInfo.InvariantCulture, + _genericTypeFormat, + context.Host.DefaultBaseClass, + baseType); + } + + public override bool Equals(object obj) + { + SetModelTypeCodeGenerator other = obj as SetModelTypeCodeGenerator; + return other != null && + base.Equals(obj) && + String.Equals(_genericTypeFormat, other._genericTypeFormat, StringComparison.Ordinal); + } + + public override int GetHashCode() + { + return HashCodeCombiner.Start() + .Add(base.GetHashCode()) + .Add(_genericTypeFormat) + .CombinedHash; + } + + public override string ToString() + { + return "Model:" + BaseType; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Common/GlobalSuppressions.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,23 @@ +// This file is used by Code Analysis to maintain SuppressMessage +// attributes that are applied to this project. +// Project-level suppressions either have no target or are given +// a specific target and scoped to a namespace, type, member, etc. +// +// To add a suppression to this file, right-click the message in the +// Error List, point to "Suppress Message(s)", and click +// "In Project Suppression File". +// You do not need to add suppressions to this file manually. + +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "RazorEngine.Compilation.CSharp")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "RazorEngine.Compilation.VisualBasic")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Templating", Scope = "namespace", Target = "RazorEngine.Templating")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1014:MarkAssembliesWithClsCompliant")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Scope = "member", Target = "RazorEngine.Compilation.CSharp.CSharpDirectCompilerService.#.ctor(System.Boolean,System.Web.Razor.Parser.MarkupParser)")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Scope = "member", Target = "RazorEngine.Compilation.VisualBasic.VBDirectCompilerService.#.ctor(System.Boolean,System.Web.Razor.Parser.MarkupParser)")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Scope = "member", Target = "RazorEngine.Templating.IsolatedTemplateService.#.ctor(RazorEngine.Compilation.ICompilerService,RazorEngine.Templating.IActivator)")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Scope = "member", Target = "RazorEngine.Templating.TemplateService.#.ctor(RazorEngine.Compilation.ICompilerService,RazorEngine.Templating.IActivator)")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "RazorEngine")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "RazorEngine.Compilation.Inspectors")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "RazorEngine.Spans")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "RazorEngine.Templating.Parallel")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Templating", Scope = "namespace", Target = "RazorEngine.Templating.Parallel")]
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Common/HashCodeCombiner.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,51 @@ +using System.Collections; + +namespace RazorEngine.Common +{ + internal class HashCodeCombiner + { + private long _combinedHash64 = 0x1505L; + + public int CombinedHash + { + get { return _combinedHash64.GetHashCode(); } + } + + public HashCodeCombiner Add(IEnumerable e) + { + if (e == null) + { + Add(0); + } + else + { + int count = 0; + foreach (object o in e) + { + Add(o); + count++; + } + Add(count); + } + return this; + } + + public HashCodeCombiner Add(int i) + { + _combinedHash64 = ((_combinedHash64 << 5) + _combinedHash64) ^ i; + return this; + } + + public HashCodeCombiner Add(object o) + { + int hashCode = (o != null) ? o.GetHashCode() : 0; + Add(hashCode); + return this; + } + + public static HashCodeCombiner Start() + { + return new HashCodeCombiner(); + } + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/CSharp/CSharpCodeParser.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,81 @@ +namespace RazorEngine.Compilation.CSharp +{ + using System.Web.Razor.Generator; + using System.Web.Razor.Text; + using System.Web.Razor.Parser; + using CodeGenerators; + + /// <summary> + /// Defines a code parser that supports the C# syntax. + /// </summary> + public class CSharpCodeParser : System.Web.Razor.Parser.CSharpCodeParser + { + #region Fields + private const string GenericTypeFormatString = "{0}<{1}>"; + private SourceLocation? _endInheritsLocation; + private bool _modelStatementFound; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="CSharpCodeParser"/>. + /// </summary> + public CSharpCodeParser() + { + MapDirectives(ModelDirective, "model"); + } + #endregion + + #region Methods + /// <summary> + /// Parses the inherits statement. + /// </summary> + protected override void InheritsDirective() + { + // Verify we're on the right keyword and accept + AssertDirective(SyntaxConstants.CSharp.InheritsKeyword); + AcceptAndMoveNext(); + _endInheritsLocation = CurrentLocation; + + InheritsDirectiveCore(); + CheckForInheritsAndModelStatements(); + } + + private void CheckForInheritsAndModelStatements() + { + if (_modelStatementFound && _endInheritsLocation.HasValue) + { + Context.OnError(_endInheritsLocation.Value, "The 'inherits' keyword is not allowed when a 'model' keyword is used."); + } + } + + /// <summary> + /// Parses the model statement. + /// </summary> + protected virtual void ModelDirective() + { + // Verify we're on the right keyword and accept + AssertDirective("model"); + AcceptAndMoveNext(); + + SourceLocation endModelLocation = CurrentLocation; + + BaseTypeDirective("The 'model' keyword must be followed by a type name on the same line.", CreateModelCodeGenerator); + + if (_modelStatementFound) + { + Context.OnError(endModelLocation, "Only one 'model' statement is allowed in a file."); + } + + _modelStatementFound = true; + + CheckForInheritsAndModelStatements(); + } + + private SpanCodeGenerator CreateModelCodeGenerator(string model) + { + return new SetModelTypeCodeGenerator(model, GenericTypeFormatString); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/CSharp/CSharpDirectCompilerService.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,43 @@ +namespace RazorEngine.Compilation.CSharp +{ + using System; + using System.Collections.Generic; + using System.Diagnostics.CodeAnalysis; + using System.Linq; + using System.Web.Razor.Parser; + + using Microsoft.CSharp; + using Microsoft.CSharp.RuntimeBinder; + + /// <summary> + /// Defines a direct compiler service for the C# syntax. + /// </summary> + public class CSharpDirectCompilerService : DirectCompilerServiceBase + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="CSharpDirectCompilerService"/>. + /// </summary> + /// <param name="strictMode">Specifies whether the strict mode parsing is enabled.</param> + /// <param name="markupParserFactory">The markup parser factory to use.</param> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed"), SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Disposed in base class: DirectCompilerServiceBase")] + public CSharpDirectCompilerService(bool strictMode = true, Func<ParserBase> markupParserFactory = null) + : base( + new CSharpRazorCodeLanguage(strictMode), + new CSharpCodeProvider(), + markupParserFactory) { } + #endregion + + #region Methods + /// <summary> + /// Returns a set of assemblies that must be referenced by the compiled template. + /// </summary> + /// <returns>The set of assemblies.</returns> + public override IEnumerable<string> IncludeAssemblies() + { + // Ensure the Microsoft.CSharp assembly is referenced to support dynamic typing. + return new[] { typeof(Binder).Assembly.Location }; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/CSharp/CSharpRazorCodeGenerator.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,78 @@ +using System; +using System.Linq; + +namespace RazorEngine.Compilation.CSharp +{ + using System.CodeDom; + using System.Web.Razor; + using System.Web.Razor.Parser.SyntaxTree; + + using Templating; + + /// <summary> + /// Defines a code generator that supports C# syntax. + /// </summary> + public class CSharpRazorCodeGenerator : System.Web.Razor.Generator.CSharpRazorCodeGenerator + { + #region Constructor + /// <summary> + /// Initializes a new instance of the <see cref="CSharpRazorCodeGenerator"/> class. + /// </summary> + /// <param name="className">Name of the class.</param> + /// <param name="rootNamespaceName">Name of the root namespace.</param> + /// <param name="sourceFileName">Name of the source file.</param> + /// <param name="host">The host.</param> + /// <param name="strictMode">Flag to specify that this generator is running in struct mode.</param> + public CSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host, bool strictMode) + : base(className, rootNamespaceName, sourceFileName, host) + { + StrictMode = strictMode; + var mvcHost = host as Compilation.RazorEngineHost; + if (mvcHost != null) + { + SetBaseTypeFromHost(mvcHost); + } + } + + private void SetBaseTypeFromHost(Compilation.RazorEngineHost mvcHost) + { + if (!mvcHost.DefaultBaseTemplateType.IsGenericType) + { + SetBaseType(mvcHost.DefaultBaseTemplateType.FullName); + } + else + { + var modelTypeName = CompilerServicesUtility.ResolveCSharpTypeName(mvcHost.DefaultModelType); + SetBaseType(mvcHost.DefaultBaseClass + "<" + modelTypeName + ">"); + } + } + + #endregion + + #region Properties + /// <summary> + /// Gets whether the code generator is running in strict mode. + /// </summary> + public bool StrictMode { get; private set; } + #endregion + + #region Methods + private void SetBaseType(string baseTypeName) + { + var baseType = new CodeTypeReference(baseTypeName); + Context.GeneratedClass.BaseTypes.Clear(); + Context.GeneratedClass.BaseTypes.Add(baseType); + } + + /// <summary> + /// Visits an error generated through parsing. + /// </summary> + /// <param name="err">The error that was generated.</param> + public override void VisitError(RazorError err) + { + if (StrictMode) + throw new TemplateParsingException(err); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/CSharp/CSharpRazorCodeLanguage.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,44 @@ +namespace RazorEngine.Compilation.CSharp +{ + using System.Web.Razor; + using System.Web.Razor.Generator; + + /// <summary> + /// Provides a razor code language that supports the C# language. + /// </summary> + public class CSharpRazorCodeLanguage : System.Web.Razor.CSharpRazorCodeLanguage + { + #region Constructor + /// <summary> + /// Initialises a new instance + /// </summary> + /// <param name="strictMode">Flag to determine whether strict mode is enabled.</param> + public CSharpRazorCodeLanguage(bool strictMode) + { + StrictMode = strictMode; + } + #endregion + + #region Properties + /// <summary> + /// Gets whether strict mode is enabled. + /// </summary> + public bool StrictMode { get; private set; } + #endregion + + #region Methods + /// <summary> + /// Creates the code generator. + /// </summary> + /// <param name="className">Name of the class.</param> + /// <param name="rootNamespaceName">Name of the root namespace.</param> + /// <param name="sourceFileName">Name of the source file.</param> + /// <param name="host">The host.</param> + /// <returns>An instance of <see cref="RazorCodeGenerator"/>.</returns> + public override RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host) + { + return new CSharpRazorCodeGenerator(className, rootNamespaceName, sourceFileName, host, StrictMode); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/CompilerServiceBase.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,248 @@ +namespace RazorEngine.Compilation +{ + using System; + using System.CodeDom; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + using System.IO; + using System.Linq; + using System.Reflection; + using System.Web.Razor; + using System.Web.Razor.Generator; + using System.Web.Razor.Parser; + + using Inspectors; + using Templating; + + /// <summary> + /// Provides a base implementation of a compiler service. + /// </summary> + public abstract class CompilerServiceBase : MarshalByRefObject, ICompilerService + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="CompilerServiceBase"/> + /// </summary> + /// <param name="codeLanguage">The code language.</param> + /// <param name="markupParserFactory">The markup parser factory.</param> + protected CompilerServiceBase(RazorCodeLanguage codeLanguage, Func<ParserBase> markupParserFactory) + { + Contract.Requires(codeLanguage != null); + + CodeLanguage = codeLanguage; + MarkupParserFactory = markupParserFactory ?? (() => new HtmlMarkupParser()); + } + #endregion + + #region Properties + /// <summary> + /// Gets or sets the set of code inspectors. + /// </summary> + public IEnumerable<ICodeInspector> CodeInspectors { get; set; } + + /// <summary> + /// Gets the code language. + /// </summary> + public RazorCodeLanguage CodeLanguage { get; private set; } + + /// <summary> + /// Gets or sets whether the compiler service is operating in debug mode. + /// </summary> + public bool Debug { get; set; } + + /// <summary> + /// Gets the markup parser. + /// </summary> + public Func<ParserBase> MarkupParserFactory { get; private set; } + #endregion + + #region Methods + + /// <summary> + /// Builds a type name for the specified template type. + /// </summary> + /// <param name="templateType">The template type.</param> + /// <returns>The string type name (including namespace).</returns> + [Pure] + public virtual string BuildTypeName(Type templateType) + { + if (templateType == null) + throw new ArgumentNullException("templateType"); + + if (!templateType.IsGenericTypeDefinition || !templateType.IsGenericType) + return templateType.FullName; + + return templateType.Namespace + + "." + + templateType.Name.Substring(0, templateType.Name.IndexOf('`')); + } + + /// <summary> + /// Compiles the type defined in the specified type context. + /// </summary> + /// <param name="context">The type context which defines the type to compile.</param> + /// <returns>The compiled type.</returns> + public abstract Tuple<Type, Assembly> CompileType(TypeContext context); + + /// <summary> + /// Creates a <see cref="RazorEngineHost"/> used for class generation. + /// </summary> + /// <param name="templateType">The template base type.</param> + /// <param name="modelType">The model type.</param> + /// <param name="className">The class name.</param> + /// <returns>An instance of <see cref="RazorEngineHost"/>.</returns> + private RazorEngineHost CreateHost(Type templateType, Type modelType, string className) + { + var host = new RazorEngineHost(CodeLanguage, MarkupParserFactory) + { + DefaultBaseTemplateType = templateType, + DefaultModelType = modelType, + DefaultBaseClass = BuildTypeName(templateType), + DefaultClassName = className, + DefaultNamespace = "CompiledRazorTemplates.Dynamic", + GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", + "WriteTo", "WriteLiteralTo", + "RazorEngine.Templating.TemplateWriter", + "DefineSection") { + ResolveUrlMethodName = "ResolveUrl" + } + }; + + return host; + } + + /// <summary> + /// Generates any required contructors for the specified type. + /// </summary> + /// <param name="constructors">The set of constructors.</param> + /// <param name="codeType">The code type declaration.</param> + [Pure] + private static void GenerateConstructors(IEnumerable<ConstructorInfo> constructors, CodeTypeDeclaration codeType) + { + if (constructors == null || !constructors.Any()) + return; + + var existingConstructors = codeType.Members.OfType<CodeConstructor>().ToArray(); + foreach (var existingConstructor in existingConstructors) + codeType.Members.Remove(existingConstructor); + + foreach (var constructor in constructors) + { + var ctor = new CodeConstructor(); + ctor.Attributes = MemberAttributes.Public; + + foreach (var param in constructor.GetParameters()) + { + ctor.Parameters.Add(new CodeParameterDeclarationExpression(param.ParameterType, param.Name)); + ctor.BaseConstructorArgs.Add(new CodeSnippetExpression(param.Name)); + } + + codeType.Members.Add(ctor); + } + } + + /// <summary> + /// Gets the code compile unit used to compile a type. + /// </summary> + /// <param name="className">The class name.</param> + /// <param name="template">The template to compile.</param> + /// <param name="namespaceImports">The set of namespace imports.</param> + /// <param name="templateType">The template type.</param> + /// <param name="modelType">The model type.</param> + /// <returns>A <see cref="CodeCompileUnit"/> used to compile a type.</returns> + [Pure] + public CodeCompileUnit GetCodeCompileUnit(string className, string template, ISet<string> namespaceImports, Type templateType, Type modelType) + { + if (string.IsNullOrEmpty(className)) + throw new ArgumentException("Class name is required."); + + if (string.IsNullOrEmpty(template)) + throw new ArgumentException("Template is required."); + + namespaceImports = namespaceImports ?? new HashSet<string>(); + templateType = templateType ?? ((modelType == null) ? typeof(TemplateBase) : typeof(TemplateBase<>)); + + // Create the RazorEngineHost + var host = CreateHost(templateType, modelType, className); + + // Add any required namespace imports + foreach (string ns in GetNamespaces(templateType, namespaceImports)) + host.NamespaceImports.Add(ns); + + // Gets the generator result. + GeneratorResults result = GetGeneratorResult(host, template); + + // Add the dynamic model attribute if the type is an anonymous type. + var type = result.GeneratedCode.Namespaces[0].Types[0]; + if (modelType != null && CompilerServicesUtility.IsAnonymousType(modelType)) + type.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(HasDynamicModelAttribute)))); + + // Generate any constructors required by the base template type. + GenerateConstructors(CompilerServicesUtility.GetConstructors(templateType), type); + + // Despatch any inspectors + Inspect(result.GeneratedCode); + + return result.GeneratedCode; + } + + /// <summary> + /// Gets the generator result. + /// </summary> + /// <param name="host">The razor engine host.</param> + /// <param name="template">The template.</param> + /// <returns>The generator result.</returns> + private static GeneratorResults GetGeneratorResult(RazorEngineHost host, string template) + { + var engine = new RazorTemplateEngine(host); + GeneratorResults result; + using (var reader = new StringReader(template)) + result = engine.GenerateCode(reader); + + return result; + } + + /// <summary> + /// Gets any required namespace imports. + /// </summary> + /// <param name="templateType">The template type.</param> + /// <param name="otherNamespaces">The requested set of namespace imports.</param> + /// <returns>A set of namespace imports.</returns> + private static IEnumerable<string> GetNamespaces(Type templateType, IEnumerable<string> otherNamespaces) + { + var templateNamespaces = templateType.GetCustomAttributes(typeof(RequireNamespacesAttribute), true) + .Cast<RequireNamespacesAttribute>() + .SelectMany(a => a.Namespaces) + .Concat(otherNamespaces) + .Distinct(); + + return templateNamespaces; + } + + /// <summary> + /// Returns a set of assemblies that must be referenced by the compiled template. + /// </summary> + /// <returns>The set of assemblies.</returns> + public virtual IEnumerable<string> IncludeAssemblies() + { + return Enumerable.Empty<string>(); + } + + /// <summary> + /// Inspects the generated code compile unit. + /// </summary> + /// <param name="unit">The code compile unit.</param> + protected virtual void Inspect(CodeCompileUnit unit) + { + Contract.Requires(unit != null); + + var ns = unit.Namespaces[0]; + var type = ns.Types[0]; + var executeMethod = type.Members.OfType<CodeMemberMethod>().Where(m => m.Name.Equals("Execute")).Single(); + + foreach (var inspector in CodeInspectors) + inspector.Inspect(unit, ns, type, executeMethod); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/CompilerServiceBuilder.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,60 @@ +namespace RazorEngine.Compilation +{ + using System.Diagnostics.Contracts; + + using Configuration; + + /// <summary> + /// Manages creation of <see cref="ICompilerService"/> instances. + /// </summary> + public static class CompilerServiceBuilder + { + #region Fields + private static ICompilerServiceFactory _factory = new DefaultCompilerServiceFactory(); + private static readonly object sync = new object(); + #endregion + + #region Methods + /// <summary> + /// Sets the <see cref="ICompilerServiceFactory"/> used to create compiler service instances. + /// </summary> + /// <param name="factory">The compiler service factory to use.</param> + public static void SetCompilerServiceFactory(ICompilerServiceFactory factory) + { + Contract.Requires(factory != null); + + lock (sync) + { + _factory = factory; + } + } + + /// <summary> + /// Gets the <see cref="ICompilerService"/> for the specfied language. + /// </summary> + /// <param name="language">The code language.</param> + /// <returns>The compiler service instance.</returns> + public static ICompilerService GetCompilerService(Language language) + { + lock (sync) + { + return _factory.CreateCompilerService(language); + } + } + + /// <summary> + /// Gets the <see cref="ICompilerService"/> for the default <see cref="Language"/>. + /// </summary> + /// <returns>The compiler service instance.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")] + public static ICompilerService GetDefaultCompilerService() + { + var config = RazorEngineConfigurationSection.GetConfiguration(); + if (config == null) + return GetCompilerService(Language.CSharp); + + return GetCompilerService(config.DefaultLanguage); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/CompilerServicesUtility.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,169 @@ +using System.Linq; + +namespace RazorEngine.Compilation +{ + using System; + using System.Collections.Generic; + using System.Diagnostics.CodeAnalysis; + using System.Dynamic; + using System.Reflection; + using System.Runtime.CompilerServices; + using System.Text.RegularExpressions; + using System.Collections; + + /// <summary> + /// Provides service methods for compilation. + /// </summary> + public static class CompilerServicesUtility + { + #region Fields + private static readonly Type DynamicType = typeof(DynamicObject); + private static readonly Type ExpandoType = typeof(ExpandoObject); + private static readonly Type EnumerableType = typeof(IEnumerable); + private static readonly Type EnumeratorType = typeof(IEnumerator); + #endregion + + #region Methods + /// <summary> + /// Determines if the specified type is an anonymous type. + /// </summary> + /// <param name="type">The type to check.</param> + /// <returns>True if the type is an anonymous type, otherwise false.</returns> + public static bool IsAnonymousType(Type type) + { + if (type == null) + throw new ArgumentNullException("type"); + + return (type.IsClass + && type.IsSealed + && type.BaseType == typeof(object) + && type.Name.StartsWith("<>", StringComparison.Ordinal) + && type.IsDefined(typeof(CompilerGeneratedAttribute), true)); + } + + /// <summary> + /// Determines if the specified type is a dynamic type. + /// </summary> + /// <param name="type">The type to check.</param> + /// <returns>True if the type is an anonymous type, otherwise false.</returns> + public static bool IsDynamicType(Type type) + { + if (type == null) + throw new ArgumentNullException("type"); + + return (DynamicType.IsAssignableFrom(type) + || ExpandoType.IsAssignableFrom(type) + || IsAnonymousType(type)); + } + + /// <summary> + /// Determines if the specified type is a compiler generated iterator type. + /// </summary> + /// <param name="type">The type to check.</param> + /// <returns>True if the type is an iterator type, otherwise false.</returns> + public static bool IsIteratorType(Type type) + { + if (type == null) + throw new ArgumentNullException("type"); + + return type.IsNestedPrivate + && type.Name.StartsWith("<", StringComparison.Ordinal) + && (EnumerableType.IsAssignableFrom(type) || EnumeratorType.IsAssignableFrom(type)); + } + + /// <summary> + /// Generates a random class name. + /// </summary> + /// <returns>A new random class name.</returns> + public static string GenerateClassName() + { + Guid guid = Guid.NewGuid(); + return Regex.Replace(guid.ToString("N"), @"[^A-Za-z]*", ""); + } + + /// <summary> + /// Gets the public or protected constructors of the specified type. + /// </summary> + /// <param name="type">The target type.</param> + /// <returns>An enumerable of constructors.</returns> + public static IEnumerable<ConstructorInfo> GetConstructors(Type type) + { + if (type == null) + throw new ArgumentNullException("type"); + + var constructors = type + .GetConstructors(BindingFlags.Public | BindingFlags.Instance); + + return constructors; + } + + public static string ResolveCSharpTypeName(Type type) + { + if (IsIteratorType(type)) + type = GetFirstGenericInterface(type); + + if (IsDynamicType(type)) + return "dynamic"; + + if (!type.IsGenericType) + return type.FullName; + + return type.Namespace + + "." + + type.Name.Substring(0, type.Name.IndexOf('`')) + + "<" + + string.Join(", ", type.GetGenericArguments().Select(ResolveCSharpTypeName)) + + ">"; + } + + public static string ResolveVBTypeName(Type type) + { + if (IsIteratorType(type)) + type = GetFirstGenericInterface(type); + + if (IsDynamicType(type)) + return "Object"; + + if (!type.IsGenericType) + return type.FullName; + + return type.Namespace + + "." + + type.Name.Substring(0, type.Name.IndexOf('`')) + + "(Of" + + string.Join(", ", type.GetGenericArguments().Select(ResolveVBTypeName)) + + ")"; + } + + /// <summary> + /// Gets the first generic interface of the specified type if one exists. + /// </summary> + /// <param name="type">The target type.</param> + /// <returns>The first generic interface if one exists, otherwise the first interface or the target type itself if there are no interfaces.</returns> + public static Type GetFirstGenericInterface(Type type) + { + Type firstInterface = null; + foreach (var @interface in type.GetInterfaces()) + { + if (firstInterface == null) + firstInterface = @interface; + + if (@interface.IsGenericType) + return @interface; + } + return @firstInterface ?? type; + } + + /// <summary> + /// Gets an enumerable of all assemblies loaded in the current domain. + /// </summary> + /// <returns>An enumerable of loaded assemblies.</returns> + [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")] + public static IEnumerable<Assembly> GetLoadedAssemblies() + { + var domain = AppDomain.CurrentDomain; + return domain.GetAssemblies(); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/DefaultCompilerServiceFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,37 @@ +namespace RazorEngine.Compilation +{ + using System; + using System.Diagnostics.CodeAnalysis; + + using CSharp; + using VisualBasic; + + /// <summary> + /// Provides a default implementation of a <see cref="ICompilerServiceFactory"/>. + /// </summary> + public class DefaultCompilerServiceFactory : ICompilerServiceFactory + { + #region Methods + /// <summary> + /// Creates a <see cref="ICompilerService"/> that supports the specified language. + /// </summary> + /// <param name="language">The <see cref="Language"/>.</param> + /// <returns>An instance of <see cref="ICompilerService"/>.</returns> + [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")] + public ICompilerService CreateCompilerService(Language language) + { + switch (language) + { + case Language.CSharp: + return new CSharpDirectCompilerService(); + + case Language.VisualBasic: + return new VBDirectCompilerService(); + + default: + throw new ArgumentException("Unsupported language: " + language); + } + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/DirectCompilerServiceBase.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,136 @@ +namespace RazorEngine.Compilation +{ + using System; + using System.CodeDom.Compiler; + using System.Diagnostics.Contracts; + using System.Globalization; + using System.IO; + using System.Linq; + using System.Reflection; + using System.Security; + using System.Text; + using System.Web.Razor; + using System.Web.Razor.Parser; + + using Templating; + + /// <summary> + /// Provides a base implementation of a direct compiler service. + /// </summary> + public abstract class DirectCompilerServiceBase : CompilerServiceBase, IDisposable + { + #region Fields + private readonly CodeDomProvider _codeDomProvider; + private bool _disposed; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="DirectCompilerServiceBase"/>. + /// </summary> + /// <param name="codeLanguage">The razor code language.</param> + /// <param name="codeDomProvider">The code dom provider used to generate code.</param> + /// <param name="markupParserFactory">The markup parser factory.</param> + protected DirectCompilerServiceBase(RazorCodeLanguage codeLanguage, CodeDomProvider codeDomProvider, Func<ParserBase> markupParserFactory) + : base(codeLanguage, markupParserFactory) + { + _codeDomProvider = codeDomProvider; + } + #endregion + + #region Methods + /// <summary> + /// Creates the compile results for the specified <see cref="TypeContext"/>. + /// </summary> + /// <param name="context">The type context.</param> + /// <returns>The compiler results.</returns> + [Pure] + private Tuple<CompilerResults, string> Compile(TypeContext context) + { + if (_disposed) + throw new ObjectDisposedException(GetType().Name); + + var compileUnit = GetCodeCompileUnit(context.ClassName, context.TemplateContent, context.Namespaces, + context.TemplateType, context.ModelType); + + var @params = new CompilerParameters + { + GenerateInMemory = true, + GenerateExecutable = false, + IncludeDebugInformation = false, + CompilerOptions = "/target:library /optimize /define:RAZORENGINE" + }; + + var assemblies = CompilerServicesUtility + .GetLoadedAssemblies() + .Where(a => !a.IsDynamic && File.Exists(a.Location)) + .GroupBy(a => a.GetName().Name).Select(grp => grp.First(y => y.GetName().Version == grp.Max(x => x.GetName().Version))) // only select distinct assemblies based on FullName to avoid loading duplicate assemblies + .Select(a => a.Location); + + var includeAssemblies = (IncludeAssemblies() ?? Enumerable.Empty<string>()); + assemblies = assemblies.Concat(includeAssemblies) + .Where(a => !string.IsNullOrWhiteSpace(a)) + .Distinct(StringComparer.InvariantCultureIgnoreCase); + + @params.ReferencedAssemblies.AddRange(assemblies.ToArray()); + + string sourceCode = null; + if (Debug) + { + var builder = new StringBuilder(); + using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture)) + { + _codeDomProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new CodeGeneratorOptions()); + sourceCode = builder.ToString(); + } + } + + return Tuple.Create(_codeDomProvider.CompileAssemblyFromDom(@params, compileUnit), sourceCode); + } + + /// <summary> + /// Compiles the type defined in the specified type context. + /// </summary> + /// <param name="context">The type context which defines the type to compile.</param> + /// <returns>The compiled type.</returns> + [Pure, SecurityCritical] + public override Tuple<Type, Assembly> CompileType(TypeContext context) + { + if (context == null) + throw new ArgumentNullException("context"); + + var result = Compile(context); + var compileResult = result.Item1; + + if (compileResult.Errors != null && compileResult.Errors.HasErrors) + throw new TemplateCompilationException(compileResult.Errors, result.Item2, context.TemplateContent); + + return Tuple.Create( + compileResult.CompiledAssembly.GetType("CompiledRazorTemplates.Dynamic." + context.ClassName), + compileResult.CompiledAssembly); + } + + /// <summary> + /// Releases managed resourced used by this instance. + /// </summary> + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// <summary> + /// Releases managed resources used by this instance. + /// </summary> + /// <param name="disposing">Are we explicily disposing of this instance?</param> + protected virtual void Dispose(bool disposing) + { + if (disposing && !_disposed) + { + _codeDomProvider.Dispose(); + _disposed = true; + } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/HasDynamicModelAttribute.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,12 @@ +namespace RazorEngine.Compilation +{ + using System; + + /// <summary> + /// Defines an attribute that marks the presence of a dynamic model in a template. + /// </summary> + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)] + public sealed class HasDynamicModelAttribute : Attribute + { + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/ICompilerService.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,48 @@ +namespace RazorEngine.Compilation +{ + using System; + using System.Collections.Generic; + using System.Reflection; + + using Inspectors; + + /// <summary> + /// Defines the required contract for implementing a compiler service. + /// </summary> + public interface ICompilerService + { + #region Properties + /// <summary> + /// Gets or sets the set of code inspectors. + /// </summary> + IEnumerable<ICodeInspector> CodeInspectors { get; set; } + + /// <summary> + /// Gets or sets whether the compiler service is operating in debug mode. + /// </summary> + bool Debug { get; set; } + #endregion + + #region Methods + /// <summary> + /// Builds a type name for the specified template type. + /// </summary> + /// <param name="templateType">The template type.</param> + /// <returns>The string type name (including namespace).</returns> + string BuildTypeName(Type templateType); + + /// <summary> + /// Compiles the type defined in the specified type context. + /// </summary> + /// <param name="context">The type context which defines the type to compile.</param> + /// <returns>The compiled type.</returns> + Tuple<Type, Assembly> CompileType(TypeContext context); + + /// <summary> + /// Returns a set of assemblies that must be referenced by the compiled template. + /// </summary> + /// <returns>The set of assemblies.</returns> + IEnumerable<string> IncludeAssemblies(); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/ICompilerServiceFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,17 @@ +namespace RazorEngine.Compilation +{ + /// <summary> + /// Defines the required contract for implementing a compiler service factory. + /// </summary> + public interface ICompilerServiceFactory + { + #region Methods + /// <summary> + /// Creates a <see cref="ICompilerService"/> that supports the specified language. + /// </summary> + /// <param name="language">The <see cref="Language"/>.</param> + /// <returns>An instance of <see cref="ICompilerService"/>.</returns> + ICompilerService CreateCompilerService(Language language); + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/Inspectors/ICodeInspector.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,21 @@ +namespace RazorEngine.Compilation.Inspectors +{ + using System.CodeDom; + + /// <summary> + /// Defines the required contract for implementing a code inspector. + /// </summary> + public interface ICodeInspector + { + #region Methods + /// <summary> + /// Inspects the specified code unit. + /// </summary> + /// <param name="unit">The code unit.</param> + /// <param name="ns">The code namespace declaration.</param> + /// <param name="type">The code type declaration.</param> + /// <param name="executeMethod">The code method declaration for the Execute method.</param> + void Inspect(CodeCompileUnit unit, CodeNamespace ns, CodeTypeDeclaration type, CodeMemberMethod executeMethod); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/RazorDynamicObject.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,80 @@ +namespace RazorEngine.Compilation +{ + using System; + using System.Diagnostics; + using System.Dynamic; + + /// <summary> + /// Defines a dynamic object. + /// </summary> + internal class RazorDynamicObject : DynamicObject + { + #region Properties + /// <summary> + /// Gets or sets the model. + /// </summary> + public object Model { get; set; } + + /// <summary> + /// Gets or sets whether to allow missing properties on dynamic members. + /// </summary> + public bool AllowMissingPropertiesOnDynamic { get; set; } + #endregion + + #region Methods + /// <summary> + /// Gets the value of the specified member. + /// </summary> + /// <param name="binder">The current binder.</param> + /// <param name="result">The member result.</param> + /// <returns>True.</returns> + [DebuggerStepThrough] + public override bool TryGetMember(GetMemberBinder binder, out object result) + { + if (binder == null) + throw new ArgumentNullException("binder"); + + var dynamicObject = Model as RazorDynamicObject; + if (dynamicObject != null) + return dynamicObject.TryGetMember(binder, out result); + + Type modelType = Model.GetType(); + var prop = modelType.GetProperty(binder.Name); + if (prop == null) + { + if (!AllowMissingPropertiesOnDynamic) + { + result = null; + return false; + } + + result = new RazorDynamicObject() { AllowMissingPropertiesOnDynamic = AllowMissingPropertiesOnDynamic, Model = new object() }; + return true; + } + + object value = prop.GetValue(Model, null); + if (value == null) + { + result = value; + return true; + } + + Type valueType = value.GetType(); + + result = (CompilerServicesUtility.IsAnonymousType(valueType)) + ? new RazorDynamicObject { Model = value } + : value; + return true; + } + + /// <summary> + /// Returns the string representation of the current instance. + /// </summary> + /// <returns>The string representation of this instance.</returns> + public override string ToString() + { + return ""; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/RazorEngineHost.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,53 @@ +namespace RazorEngine.Compilation +{ + using System; + using System.Web.Razor; + using System.Web.Razor.Parser; + + /// <summary> + /// Defines the custom razor engine host. + /// </summary> + public class RazorEngineHost : System.Web.Razor.RazorEngineHost + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="RazorEngineHost"/>. + /// </summary> + /// <param name="language">The code language.</param> + /// <param name="markupParserFactory">The markup parser factory delegate.</param> + public RazorEngineHost(RazorCodeLanguage language, Func<ParserBase> markupParserFactory) + : base(language, markupParserFactory) { } + #endregion + + #region Properties + /// <summary> + /// Gets or sets the default template type. + /// </summary> + public Type DefaultBaseTemplateType { get; set; } + + /// <summary> + /// Gets or sets the default model type. + /// </summary> + public Type DefaultModelType { get; set; } + + #endregion + + #region Methods + /// <summary> + /// Decorates the code parser. + /// </summary> + /// <param name="incomingCodeParser">The code parser.</param> + /// <returns>The decorated parser.</returns> + public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser) + { + if (incomingCodeParser is CSharpCodeParser) + return new CSharp.CSharpCodeParser(); + + if (incomingCodeParser is VBCodeParser) + return new VisualBasic.VBCodeParser(); + + return base.DecorateCodeParser(incomingCodeParser); + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/TypeContext.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,49 @@ +namespace RazorEngine.Compilation +{ + using System; + using System.Collections.Generic; + + /// <summary> + /// Defines a type context that describes a template to compile. + /// </summary> + public class TypeContext : MarshalByRefObject + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="TypeContext"/>. + /// </summary> + internal TypeContext() + { + ClassName = CompilerServicesUtility.GenerateClassName(); + Namespaces = new HashSet<string>(); + } + #endregion + + #region Properties + /// <summary> + /// Gets the class name. + /// </summary> + public string ClassName { get; private set; } + + /// <summary> + /// Gets or sets the model type. + /// </summary> + public Type ModelType { get; set; } + + /// <summary> + /// Gets the set of namespace imports. + /// </summary> + public ISet<string> Namespaces { get; private set; } + + /// <summary> + /// Gets or sets the template content. + /// </summary> + public string TemplateContent { get; set; } + + /// <summary> + /// Gets or sets the base template type. + /// </summary> + public Type TemplateType { get; set; } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/VisualBasic/VBCodeParser.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,110 @@ + +namespace RazorEngine.Compilation.VisualBasic +{ + using System; + using System.Linq; + using System.Web.Razor.Generator; + using System.Web.Razor.Tokenizer.Symbols; + using System.Web.Razor.Parser.SyntaxTree; + using System.Web.Razor.Text; + using CodeGenerators; + + /// <summary> + /// Defines a code parser that supports the VB syntax. + /// </summary> + public class VBCodeParser : System.Web.Razor.Parser.VBCodeParser + { + #region Fields + private const string GenericTypeFormatString = "{0}(Of {1})"; + private SourceLocation? _endInheritsLocation; + private bool _modelStatementFound; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="VBCodeParser"/> + /// </summary> + public VBCodeParser() + { + MapDirective("ModelType", ModelTypeDirective); + } + #endregion + + #region Methods + /// <summary> + /// Parses the inherits statement. + /// </summary> + protected override bool InheritsStatement() + { + // Verify we're on the right keyword and accept + Assert(VBKeyword.Inherits); + VBSymbol inherits = CurrentSymbol; + NextToken(); + _endInheritsLocation = CurrentLocation; + PutCurrentBack(); + PutBack(inherits); + EnsureCurrent(); + + bool result = base.InheritsStatement(); + CheckForInheritsAndModelStatements(); + return result; + } + + private void CheckForInheritsAndModelStatements() + { + if (_modelStatementFound && _endInheritsLocation.HasValue) + { + Context.OnError(_endInheritsLocation.Value, "The 'inherits' keyword is not allowed when a 'ModelType' keyword is used."); + } + } + + /// <summary> + /// Parses the modeltype statement. + /// </summary> + protected virtual bool ModelTypeDirective() + { + AssertDirective("ModelType"); + + Span.CodeGenerator = SpanCodeGenerator.Null; + Context.CurrentBlock.Type = BlockType.Directive; + + AcceptAndMoveNext(); + SourceLocation endModelLocation = CurrentLocation; + + if (At(VBSymbolType.WhiteSpace)) + { + Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None; + } + + AcceptWhile(VBSymbolType.WhiteSpace); + Output(SpanKind.MetaCode); + + if (_modelStatementFound) + { + Context.OnError(endModelLocation, "Only one 'ModelType' statement is allowed in a file."); + } + _modelStatementFound = true; + + if (EndOfFile || At(VBSymbolType.WhiteSpace) || At(VBSymbolType.NewLine)) + { + Context.OnError(endModelLocation, "The 'ModelType' keyword must be followed by a type name on the same line."); + } + + // Just accept to a newline + AcceptUntil(VBSymbolType.NewLine); + if (!Context.DesignTimeMode) + { + // We want the newline to be treated as code, but it causes issues at design-time. + Optional(VBSymbolType.NewLine); + } + + string baseType = String.Concat(Span.Symbols.Select(s => s.Content)).Trim(); + Span.CodeGenerator = new SetModelTypeCodeGenerator(baseType, GenericTypeFormatString); + + CheckForInheritsAndModelStatements(); + Output(SpanKind.Code); + return false; + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/VisualBasic/VBDirectCompilerService.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,28 @@ +namespace RazorEngine.Compilation.VisualBasic +{ + using System; + using System.Diagnostics.CodeAnalysis; + using System.Web.Razor.Parser; + + using Microsoft.VisualBasic; + + /// <summary> + /// Defines a direct compiler service for the VB syntax. + /// </summary> + public class VBDirectCompilerService : DirectCompilerServiceBase + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="VBDirectCompilerService"/>. + /// </summary> + /// <param name="strictMode">Specifies whether the strict mode parsing is enabled.</param> + /// <param name="markupParserFactory">The markup parser to use.</param> + [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Disposed in base class: DirectCompilerServiceBase")] + public VBDirectCompilerService(bool strictMode = true, Func<ParserBase> markupParserFactory = null) + : base( + new VBRazorCodeLanguage(strictMode), + new VBCodeProvider(), + markupParserFactory) { } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/VisualBasic/VBRazorCodeGenerator.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,47 @@ +namespace RazorEngine.Compilation.VisualBasic +{ + using System.Web.Razor; + using System.Web.Razor.Parser.SyntaxTree; + using Templating; + + /// <summary> + /// Defines a code generator that supports VB syntax. + /// </summary> + public class VBRazorCodeGenerator : System.Web.Razor.Generator.VBRazorCodeGenerator + { + #region Constructor + /// <summary> + /// Initializes a new instance of the <see cref="VBRazorCodeGenerator"/> class. + /// </summary> + /// <param name="className">Name of the class.</param> + /// <param name="rootNamespaceName">Name of the root namespace.</param> + /// <param name="sourceFileName">Name of the source file.</param> + /// <param name="host">The host.</param> + /// <param name="strictMode">Flag to specify that this generator is running in struct mode.</param> + public VBRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host, bool strictMode) + : base(className, rootNamespaceName, sourceFileName, host) + { + StrictMode = strictMode; + } + #endregion + + #region Properties + /// <summary> + /// Gets whether the code generator is running in strict mode. + /// </summary> + public bool StrictMode { get; private set; } + #endregion + + #region Methods + /// <summary> + /// Visits an error generated through parsing. + /// </summary> + /// <param name="err">The error that was generated.</param> + public override void VisitError(RazorError err) + { + if (StrictMode) + throw new TemplateParsingException(err); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Compilation/VisualBasic/VBRazorCodeLanguage.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,44 @@ +namespace RazorEngine.Compilation.VisualBasic +{ + using System.Web.Razor; + using System.Web.Razor.Generator; + + /// <summary> + /// Provides a razor code language that supports the VB language. + /// </summary> + public class VBRazorCodeLanguage : System.Web.Razor.VBRazorCodeLanguage + { + #region Constructor + /// <summary> + /// Initialises a new instance + /// </summary> + /// <param name="strictMode">Flag to determine whether strict mode is enabled.</param> + public VBRazorCodeLanguage(bool strictMode) + { + StrictMode = strictMode; + } + #endregion + + #region Properties + /// <summary> + /// Gets whether strict mode is enabled. + /// </summary> + public bool StrictMode { get; private set; } + #endregion + + #region Methods + /// <summary> + /// Creates the code generator. + /// </summary> + /// <param name="className">Name of the class.</param> + /// <param name="rootNamespaceName">Name of the root namespace.</param> + /// <param name="sourceFileName">Name of the source file.</param> + /// <param name="host">The host.</param> + /// <returns>An instance of <see cref="RazorCodeGenerator"/>.</returns> + public override RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host) + { + return new VBRazorCodeGenerator(className, rootNamespaceName, sourceFileName, host, StrictMode); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Fluent/FluentConfigurationBuilder.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,285 @@ +namespace RazorEngine.Configuration +{ + using System; + using System.Diagnostics.Contracts; + + using Compilation; + using Compilation.Inspectors; + using Templating; + using Text; + + /// <summary> + /// Provides a default implementation of a <see cref="IConfigurationBuilder"/>. + /// </summary> + internal class FluentConfigurationBuilder : IConfigurationBuilder + { + #region Fields + private readonly TemplateServiceConfiguration _config; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="FluentConfigurationBuilder"/>. + /// </summary> + /// <param name="config">The default configuration that we build a new configuration from.</param> + public FluentConfigurationBuilder(TemplateServiceConfiguration config) + { + Contract.Requires(config != null); + + _config = config; + } + #endregion + + #region Methods + /// <summary> + /// Sets the activator. + /// </summary> + /// <param name="activator">The activator instance.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder ActivateUsing(IActivator activator) + { + if (activator == null) + throw new ArgumentNullException("activator"); + + _config.Activator = activator; + return this; + } + + /// <summary> + /// Sets the activator. + /// </summary> + /// <typeparam name="TActivator">The activator type.</typeparam> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder ActivateUsing<TActivator>() where TActivator : IActivator, new() + { + return ActivateUsing(new TActivator()); + } + + /// <summary> + /// Sets the activator. + /// </summary> + /// <param name="activator">The activator delegate.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder ActivateUsing(Func<InstanceContext, ITemplate> activator) + { + if (activator == null) + throw new ArgumentNullException("activator"); + + _config.Activator = new DelegateActivator(activator); + return this; + } + + /// <summary> + /// Adds the specified code inspector. + /// </summary> + /// <typeparam name="TInspector">The code inspector type.</typeparam> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder AddInspector<TInspector>() where TInspector : ICodeInspector, new() + { + return AddInspector(new TInspector()); + } + + /// <summary> + /// Adds the specified code inspector. + /// </summary> + /// <param name="inspector">The code inspector.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder AddInspector(ICodeInspector inspector) + { + if (inspector == null) + throw new ArgumentNullException("inspector"); + + _config.CodeInspectors.Add(inspector); + return this; + } + + /// <summary> + /// Sets that dynamic models should be fault tollerant in accepting missing properties. + /// </summary> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder AllowMissingPropertiesOnDynamic() + { + _config.AllowMissingPropertiesOnDynamic = true; + + return this; + } + + /// <summary> + /// Sets the compiler service factory. + /// </summary> + /// <param name="factory">The compiler service factory.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder CompileUsing(ICompilerServiceFactory factory) + { + if (factory == null) + throw new ArgumentNullException("factory"); + + _config.CompilerServiceFactory = factory; + return this; + } + + /// <summary> + /// Sets the compiler service factory. + /// </summary> + /// <typeparam name="TCompilerServiceFactory">The compiler service factory type.</typeparam> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder CompileUsing<TCompilerServiceFactory>() + where TCompilerServiceFactory : ICompilerServiceFactory, new() + { + return CompileUsing(new TCompilerServiceFactory()); + } + + /// <summary> + /// Sets the encoded string factory. + /// </summary> + /// <param name="factory">The encoded string factory.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder EncodeUsing(IEncodedStringFactory factory) + { + if (factory == null) + throw new ArgumentNullException("factory"); + + _config.EncodedStringFactory = factory; + return this; + } + + /// <summary> + /// Sets the encoded string factory. + /// </summary> + /// <typeparam name="TEncodedStringFactory">The encoded string factory type.</typeparam> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder EncodeUsing<TEncodedStringFactory>() + where TEncodedStringFactory : IEncodedStringFactory, new() + { + return EncodeUsing(new TEncodedStringFactory()); + } + + /// <summary> + /// Includes the specified namespaces + /// </summary> + /// <param name="namespaces">The set of namespaces to include.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder IncludeNamespaces(params string[] namespaces) + { + if (namespaces == null) + throw new ArgumentNullException("namespaces"); + + foreach (string ns in namespaces) + _config.Namespaces.Add(ns); + + return this; + } + + /// <summary> + /// Sets the resolve used to locate unknown templates. + /// </summary> + /// <typeparam name="TResolver">The resolve type.</typeparam> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder ResolveUsing<TResolver>() where TResolver : ITemplateResolver, new() + { + _config.Resolver = new TResolver(); + return this; + } + + /// <summary> + /// Sets the resolver used to locate unknown templates. + /// </summary> + /// <param name="resolver">The resolver instance to use.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder ResolveUsing(ITemplateResolver resolver) + { + Contract.Requires(resolver != null); + + _config.Resolver = resolver; + return this; + } + + /// <summary> + /// Sets the resolver delegate used to locate unknown templates. + /// </summary> + /// <param name="resolver">The resolver delegate to use.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder ResolveUsing(Func<string, string> resolver) + { + Contract.Requires(resolver != null); + + _config.Resolver = new DelegateTemplateResolver(resolver); + return this; + } + + /// <summary> + /// Sets the default activator. + /// </summary> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder UseDefaultActivator() + { + _config.Activator = new DefaultActivator(); + return this; + } + + /// <summary> + /// Sets the default compiler service factory. + /// </summary> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder UseDefaultCompilerServiceFactory() + { + _config.CompilerServiceFactory = new DefaultCompilerServiceFactory(); + return this; + } + + /// <summary> + /// Sets the default encoded string factory. + /// </summary> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder UseDefaultEncodedStringFactory() + { + _config.EncodedStringFactory = new HtmlEncodedStringFactory(); + return this; + } + + /// <summary> + /// Sets the base template type. + /// </summary> + /// <param name="baseTemplateType">The base template type.</param> + /// <returns>The current configuration builder/.</returns> + public IConfigurationBuilder WithBaseTemplateType(Type baseTemplateType) + { + _config.BaseTemplateType = baseTemplateType; + return this; + } + + /// <summary> + /// Sets the code language. + /// </summary> + /// <param name="language">The code language.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder WithCodeLanguage(Language language) + { + _config.Language = language; + return this; + } + + /// <summary> + /// Sets the encoding. + /// </summary> + /// <param name="encoding">The encoding.</param> + /// <returns>The current configuration builder.</returns> + public IConfigurationBuilder WithEncoding(Encoding encoding) + { + switch (encoding) + { + case Encoding.Html: + _config.EncodedStringFactory = new HtmlEncodedStringFactory(); + break; + case Encoding.Raw: + _config.EncodedStringFactory = new RawStringFactory(); + break; + default: + throw new ArgumentException("Unsupported encoding: " + encoding); + } + + return this; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Fluent/FluentTemplateServiceConfiguration.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,116 @@ +namespace RazorEngine.Configuration +{ + using System; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + + using Compilation; + using Compilation.Inspectors; + using Templating; + using Text; + + /// <summary> + /// Defines a fluent template service configuration + /// </summary> + public class FluentTemplateServiceConfiguration : ITemplateServiceConfiguration + { + #region Fields + private readonly TemplateServiceConfiguration _innerConfig = new TemplateServiceConfiguration(); + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="FluentTemplateServiceConfiguration"/>. + /// </summary> + /// <param name="config">The delegate used to create the configuration.</param> + public FluentTemplateServiceConfiguration(Action<IConfigurationBuilder> config) + { + Contract.Requires(config != null); + + config(new FluentConfigurationBuilder(_innerConfig)); + } + #endregion + + #region Properties + /// <summary> + /// Gets or sets the activator. + /// </summary> + public IActivator Activator + { + get { return _innerConfig.Activator; } + } + + /// <summary> + /// Gets or sets whether to allow missing properties on dynamic models. + /// </summary> + public bool AllowMissingPropertiesOnDynamic + { + get { return _innerConfig.AllowMissingPropertiesOnDynamic; } + } + + /// <summary> + /// Gets the base template type. + /// </summary> + public Type BaseTemplateType + { + get { return _innerConfig.BaseTemplateType; } + } + + /// <summary> + /// Gets the set of code inspectors. + /// </summary> + public IEnumerable<ICodeInspector> CodeInspectors + { + get { return _innerConfig.CodeInspectors; } + } + + /// <summary> + /// Gets or sets the compiler service factory. + /// </summary> + public ICompilerServiceFactory CompilerServiceFactory + { + get { return _innerConfig.CompilerServiceFactory; } + } + + /// <summary> + /// Gets whether the template service is operating in debug mode. + /// </summary> + public bool Debug + { + get { return _innerConfig.Debug; } + } + + /// <summary> + /// Gets or sets the encoded string factory. + /// </summary> + public IEncodedStringFactory EncodedStringFactory + { + get { return _innerConfig.EncodedStringFactory; } + } + + /// <summary> + /// Gets or sets the language. + /// </summary> + public Language Language + { + get { return _innerConfig.Language; } + } + + /// <summary> + /// Gets or sets the collection of namespaces. + /// </summary> + public ISet<string> Namespaces + { + get { return _innerConfig.Namespaces; } + } + + /// <summary> + /// Gets the resolver. + /// </summary> + public ITemplateResolver Resolver + { + get { return _innerConfig.Resolver; } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Fluent/IConfigurationBuilder.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,148 @@ +namespace RazorEngine.Configuration +{ + using System; + + using Compilation; + using Compilation.Inspectors; + using Templating; + using Text; + + /// <summary> + /// Defines the required contract for implementing a configuration builder. + /// </summary> + public interface IConfigurationBuilder + { + #region Methods + /// <summary> + /// Sets the activator. + /// </summary> + /// <param name="activator">The activator instance.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder ActivateUsing(IActivator activator); + + /// <summary> + /// Sets the activator. + /// </summary> + /// <typeparam name="TActivator">The activator type.</typeparam> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder ActivateUsing<TActivator>() where TActivator : IActivator, new(); + + /// <summary> + /// Sets the activator. + /// </summary> + /// <param name="activator">The activator delegate.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder ActivateUsing(Func<InstanceContext, ITemplate> activator); + + /// <summary> + /// Adds the specified code inspector. + /// </summary> + /// <typeparam name="TInspector">The code inspector type.</typeparam> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder AddInspector<TInspector>() where TInspector : ICodeInspector, new(); + + /// <summary> + /// Adds the specified code inspector. + /// </summary> + /// <param name="inspector">The code inspector.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder AddInspector(ICodeInspector inspector); + + /// <summary> + /// Sets the compiler service factory. + /// </summary> + /// <param name="factory">The compiler service factory.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder CompileUsing(ICompilerServiceFactory factory); + + /// <summary> + /// Sets the compiler service factory. + /// </summary> + /// <typeparam name="TCompilerServiceFactory">The compiler service factory type.</typeparam> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder CompileUsing<TCompilerServiceFactory>() + where TCompilerServiceFactory : ICompilerServiceFactory, new(); + + /// <summary> + /// Sets the encoded string factory. + /// </summary> + /// <param name="factory">The encoded string factory.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder EncodeUsing(IEncodedStringFactory factory); + + /// <summary> + /// Sets the encoded string factory. + /// </summary> + /// <typeparam name="TEncodedStringFactory">The encoded string factory type.</typeparam> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder EncodeUsing<TEncodedStringFactory>() where TEncodedStringFactory : IEncodedStringFactory, new(); + + /// <summary> + /// Sets the resolve used to locate unknown templates. + /// </summary> + /// <typeparam name="TResolver">The resolve type.</typeparam> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder ResolveUsing<TResolver>() where TResolver : ITemplateResolver, new(); + + /// <summary> + /// Sets the resolver used to locate unknown templates. + /// </summary> + /// <param name="resolver">The resolver instance to use.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder ResolveUsing(ITemplateResolver resolver); + + /// <summary> + /// Sets the resolver delegate used to locate unknown templates. + /// </summary> + /// <param name="resolver">The resolver delegate to use.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder ResolveUsing(Func<string, string> resolver); + + /// <summary> + /// Includes the specified namespaces + /// </summary> + /// <param name="namespaces">The set of namespaces to include.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder IncludeNamespaces(params string[] namespaces); + + /// <summary> + /// Sets the default activator. + /// </summary> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder UseDefaultActivator(); + + /// <summary> + /// Sets the default compiler service factory. + /// </summary> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder UseDefaultCompilerServiceFactory(); + + /// <summary> + /// Sets the default encoded string factory. + /// </summary> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder UseDefaultEncodedStringFactory(); + + /// <summary> + /// Sets the base template type. + /// </summary> + /// <param name="baseTemplateType">The base template type.</param> + /// <returns>The current configuration builder/.</returns> + IConfigurationBuilder WithBaseTemplateType(Type baseTemplateType); + + /// <summary> + /// Sets the code language. + /// </summary> + /// <param name="language">The code language.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder WithCodeLanguage(Language language); + + /// <summary> + /// Sets the encoding. + /// </summary> + /// <param name="encoding">The encoding.</param> + /// <returns>The current configuration builder.</returns> + IConfigurationBuilder WithEncoding(Encoding encoding); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/ITemplateServiceConfiguration.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,68 @@ +namespace RazorEngine.Configuration +{ + using System; + using System.Collections.Generic; + + using Compilation; + using Compilation.Inspectors; + using Templating; + using Text; + + /// <summary> + /// Defines the required contract for implementing template service configuration. + /// </summary> + public interface ITemplateServiceConfiguration + { + #region Properties + /// <summary> + /// Gets the activator. + /// </summary> + IActivator Activator { get; } + + /// <summary> + /// Gets or sets whether to allow missing properties on dynamic models. + /// </summary> + bool AllowMissingPropertiesOnDynamic { get; } + + /// <summary> + /// Gets the base template type. + /// </summary> + Type BaseTemplateType { get; } + + /// <summary> + /// Gets the code inspectors. + /// </summary> + IEnumerable<ICodeInspector> CodeInspectors { get; } + + /// <summary> + /// Gets the compiler service factory. + /// </summary> + ICompilerServiceFactory CompilerServiceFactory { get; } + + /// <summary> + /// Gets whether the template service is operating in debug mode. + /// </summary> + bool Debug { get; } + + /// <summary> + /// Gets the encoded string factory. + /// </summary> + IEncodedStringFactory EncodedStringFactory { get; } + + /// <summary> + /// Gets the language. + /// </summary> + Language Language { get; } + + /// <summary> + /// Gets the namespaces. + /// </summary> + ISet<string> Namespaces { get; } + + /// <summary> + /// Gets the template resolver. + /// </summary> + ITemplateResolver Resolver { get; } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/RazorEngineConfigurationSection.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,100 @@ +namespace RazorEngine.Configuration +{ + using System.Configuration; + + using Xml; + + /// <summary> + /// Defines the main configuration section for the RazorEngine. + /// </summary> + public class RazorEngineConfigurationSection : ConfigurationSection + { + #region Fields + private const string ActivatorAttribute = "activatorType"; + private const string AllowMissingPropertiesOnDynamicAttribute = "allowMissingPropertiesOnDynamic"; + private const string CompilerServiceFactoryAttribute = "compilerServiceFactoryType"; + private const string DefaultLanguageAttribute = "defaultLanguage"; + private const string NamespacesElement = "namespaces"; + private const string SectionPath = "razorEngine"; + private const string TemplateResolverAttribute = "templateResolverType"; + private const string TemplateServicesElement = "templateServices"; + #endregion + + #region Properties + /// <summary> + /// Gets the activator type. + /// </summary> + [ConfigurationProperty(ActivatorAttribute, IsRequired = false)] + public string ActivatorType + { + get { return (string)this[ActivatorAttribute]; } + } + + /// <summary> + /// Gets or sets whether to allow missing properties on dynamic models. + /// </summary> + [ConfigurationProperty(AllowMissingPropertiesOnDynamicAttribute, IsRequired = false, DefaultValue = false)] + public bool AllowMissingPropertiesOnDynamic + { + get { return (bool)this[AllowMissingPropertiesOnDynamicAttribute]; } + } + + /// <summary> + /// Gets the compiler service factory type. + /// </summary> + [ConfigurationProperty(CompilerServiceFactoryAttribute, IsRequired = false)] + public string CompilerServiceFactoryType + { + get { return (string)this[CompilerServiceFactoryAttribute]; } + } + + /// <summary> + /// Gets or sets the default language. + /// </summary> + [ConfigurationProperty(DefaultLanguageAttribute, DefaultValue = Language.CSharp, IsRequired = false)] + public Language DefaultLanguage + { + get { return (Language)this[DefaultLanguageAttribute]; } + set { this[DefaultLanguageAttribute] = value; } + } + + /// <summary> + /// Gets the collection of namespaces. + /// </summary> + [ConfigurationProperty(NamespacesElement, IsRequired = false)] + public NamespaceConfigurationElementCollection Namespaces + { + get { return (NamespaceConfigurationElementCollection)this[NamespacesElement]; } + } + + /// <summary> + /// Gets the template resolver type. + /// </summary> + [ConfigurationProperty(TemplateResolverAttribute, IsRequired = false)] + public string TemplateResolverType + { + get { return (string)this[TemplateResolverAttribute]; } + } + + /// <summary> + /// Gets the collection of template service configurations. + /// </summary> + [ConfigurationProperty(TemplateServicesElement, IsRequired = false)] + public TemplateServiceConfigurationElementCollection TemplateServices + { + get { return (TemplateServiceConfigurationElementCollection)this[TemplateServicesElement]; } + } + #endregion + + #region Methods + /// <summary> + /// Gets an instance of <see cref="RazorEngineConfigurationSection"/> that represents the current configuration. + /// </summary> + /// <returns>An instance of <see cref="RazorEngineConfigurationSection"/>, or null if no configuration is specified.</returns> + public static RazorEngineConfigurationSection GetConfiguration() + { + return ConfigurationManager.GetSection(SectionPath) as RazorEngineConfigurationSection; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/TemplateServiceConfiguration.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,98 @@ +namespace RazorEngine.Configuration +{ + using System; + using System.Collections.Generic; + + using Compilation; + using Compilation.Inspectors; + using Templating; + using Text; + + /// <summary> + /// Provides a default implementation of a template service configuration. + /// </summary> + public class TemplateServiceConfiguration : ITemplateServiceConfiguration + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="TemplateServiceConfiguration"/>. + /// </summary> + public TemplateServiceConfiguration() + { + Activator = new DefaultActivator(); + CompilerServiceFactory = new DefaultCompilerServiceFactory(); + EncodedStringFactory = new HtmlEncodedStringFactory(); + CodeInspectors = new List<ICodeInspector>(); + + Namespaces = new HashSet<string> + { + "System", + "System.Collections.Generic", + "System.Linq" + }; + + var config = RazorEngineConfigurationSection.GetConfiguration(); + Language = (config == null) + ? Language.CSharp + : config.DefaultLanguage; + } + #endregion + + #region Properties + /// <summary> + /// Gets or sets the activator. + /// </summary> + public IActivator Activator { get; set; } + + /// <summary> + /// Gets or sets whether to allow missing properties on dynamic models. + /// </summary> + public bool AllowMissingPropertiesOnDynamic { get; set; } + + /// <summary> + /// Gets or sets the base template type. + /// </summary> + public Type BaseTemplateType { get; set; } + + /// <summary> + /// Gets the set of code inspectors. + /// </summary> + IEnumerable<ICodeInspector> ITemplateServiceConfiguration.CodeInspectors { get { return CodeInspectors; } } + + /// <summary> + /// Gets the set of code inspectors. + /// </summary> + public IList<ICodeInspector> CodeInspectors { get; private set; } + + /// <summary> + /// Gets or sets the compiler service factory. + /// </summary> + public ICompilerServiceFactory CompilerServiceFactory { get; set; } + + /// <summary> + /// Gets whether the template service is operating in debug mode. + /// </summary> + public bool Debug { get; set; } + + /// <summary> + /// Gets or sets the encoded string factory. + /// </summary> + public IEncodedStringFactory EncodedStringFactory { get; set; } + + /// <summary> + /// Gets or sets the language. + /// </summary> + public Language Language { get; set; } + + /// <summary> + /// Gets or sets the collection of namespaces. + /// </summary> + public ISet<string> Namespaces { get; set; } + + /// <summary> + /// Gets or sets the template resolver. + /// </summary> + public ITemplateResolver Resolver { get; set; } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Xml/NamespaceConfigurationElement.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,25 @@ +namespace RazorEngine.Configuration.Xml +{ + using System.Configuration; + + /// <summary> + /// Defines a configuration of a namespace. + /// </summary> + public class NamespaceConfigurationElement : ConfigurationElement + { + #region Fields + private const string NamespaceAttribute = "namespace"; + #endregion + + #region Properties + /// <summary> + /// Gets the namespace. + /// </summary> + [ConfigurationProperty(NamespaceAttribute, IsRequired = true)] + public string Namespace + { + get { return (string)this[NamespaceAttribute]; } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Xml/NamespaceConfigurationElementCollection.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,32 @@ +namespace RazorEngine.Configuration.Xml +{ + using System.Configuration; + + /// <summary> + /// Defines a collection of <see cref="NamespaceConfigurationElement"/> instances. + /// </summary> + [ConfigurationCollection(typeof(TemplateServiceConfigurationElement))] + public class NamespaceConfigurationElementCollection : ConfigurationElementCollection + { + #region Methods + /// <summary> + /// Creates a new <see cref="ConfigurationElement"/> for use with the collection. + /// </summary> + /// <returns>The <see cref="ConfigurationElement"/> instance.</returns> + protected override ConfigurationElement CreateNewElement() + { + return new NamespaceConfigurationElement(); + } + + /// <summary> + /// Gets a unique key for the specified element. + /// </summary> + /// <param name="element">The configuration element.</param> + /// <returns>The key for the element.</returns> + protected override object GetElementKey(ConfigurationElement element) + { + return ((NamespaceConfigurationElement)element).Namespace; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Xml/TemplateServiceConfigurationElement.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,76 @@ +namespace RazorEngine.Configuration.Xml +{ + using System.Configuration; + + /// <summary> + /// Defines a configuration of a template service. + /// </summary> + public class TemplateServiceConfigurationElement : ConfigurationElement + { + #region Fields + private const string BaseTemplateTypeAttribute = "baseTemplateType"; + private const string CodeInspectorsElement = "codeInspectors"; + private const string DebugAttribute = "debug"; + private const string EncodedStringFactoryAttribute = "encodedStringFactoryType"; + private const string LanguageAttribute = "language"; + private const string NameAttribute = "name"; + private const string NamespacesElement = "namespaces"; + #endregion + + #region Properties + /// <summary> + /// Gets the base template type. + /// </summary> + [ConfigurationProperty(BaseTemplateTypeAttribute, IsRequired = false)] + public string BaseTemplateType + { + get { return (string)this[BaseTemplateTypeAttribute]; } + } + + /// <summary> + /// Gets whether the template service is in debug mode. + /// </summary> + [ConfigurationProperty(DebugAttribute, IsRequired = false, DefaultValue = false)] + public bool Debug + { + get { return (bool)this[DebugAttribute]; } + } + + /// <summary> + /// Gets the encoded string factory type. + /// </summary> + [ConfigurationProperty(EncodedStringFactoryAttribute, IsRequired = false)] + public string EncodedStringFactoryType + { + get { return (string)this[EncodedStringFactoryAttribute]; } + } + + /// <summary> + /// Gets the language. + /// </summary> + [ConfigurationProperty(LanguageAttribute, IsRequired = false, DefaultValue = Language.CSharp)] + public Language Language + { + get { return (Language)this[LanguageAttribute]; } + } + + /// <summary> + /// Gets the name of the template service. + /// </summary> + [ConfigurationProperty(NameAttribute, IsRequired = true, IsKey = true)] + public string Name + { + get { return (string)this[NameAttribute]; } + } + + /// <summary> + /// Gets the collection of namespaces. + /// </summary> + [ConfigurationProperty(NamespacesElement, IsRequired = false)] + public NamespaceConfigurationElementCollection Namespaces + { + get { return (NamespaceConfigurationElementCollection)this[NamespacesElement]; } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Xml/TemplateServiceConfigurationElementCollection.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,32 @@ +namespace RazorEngine.Configuration.Xml +{ + using System.Configuration; + + /// <summary> + /// Defines a collection of <see cref="TemplateServiceConfigurationElement"/> instances. + /// </summary> + [ConfigurationCollection(typeof(TemplateServiceConfigurationElement), AddItemName = "service")] + public class TemplateServiceConfigurationElementCollection : ConfigurationElementCollection + { + #region Methods + /// <summary> + /// Creates a new <see cref="ConfigurationElement"/> for use with the collection. + /// </summary> + /// <returns>The <see cref="ConfigurationElement"/> instance.</returns> + protected override ConfigurationElement CreateNewElement() + { + return new TemplateServiceConfigurationElement(); + } + + /// <summary> + /// Gets a unique key for the specified element. + /// </summary> + /// <param name="element">The configuration element.</param> + /// <returns>The key for the element.</returns> + protected override object GetElementKey(ConfigurationElement element) + { + return ((TemplateServiceConfigurationElement)element).Name; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Configuration/Xml/XmlTemplateServiceConfiguration.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,247 @@ +namespace RazorEngine.Configuration.Xml +{ + using System; + using System.Collections.Generic; + using System.Configuration; + using System.Linq; + + using Compilation; + using Compilation.Inspectors; + using Templating; + using Text; + + /// <summary> + /// Represents a template service configuration that supports the xml configuration mechanism. + /// </summary> + public class XmlTemplateServiceConfiguration : ITemplateServiceConfiguration + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="XmlTemplateServiceConfiguration"/>. + /// </summary> + /// <param name="name">The name of the template service configuration.</param> + public XmlTemplateServiceConfiguration(string name) + { + if (string.IsNullOrWhiteSpace(name)) + throw new ArgumentException("'name' is a required parameter.", "name"); + + Namespaces = new HashSet<string>(); + + InitialiseConfiguration(name); + } + #endregion + + #region Properties + /// <summary> + /// Gets the activator. + /// </summary> + public IActivator Activator { get; private set; } + + /// <summary> + /// Gets or sets whether to allow missing properties on dynamic models. + /// </summary> + public bool AllowMissingPropertiesOnDynamic { get; private set; } + + /// <summary> + /// Gets the base template type. + /// </summary> + public Type BaseTemplateType { get; private set; } + + /// <summary> + /// Gets the code inspectors. + /// </summary> + public IEnumerable<ICodeInspector> CodeInspectors { get; private set; } + + /// <summary> + /// Gets the compiler service factory. + /// </summary> + public ICompilerServiceFactory CompilerServiceFactory { get; private set; } + + /// <summary> + /// Gets whether the template service is operating in debug mode. + /// </summary> + public bool Debug { get; private set; } + + /// <summary> + /// Gets the encoded string factory. + /// </summary> + public IEncodedStringFactory EncodedStringFactory { get; private set; } + + /// <summary> + /// Gets the language. + /// </summary> + public Language Language { get; private set; } + + /// <summary> + /// Gets the namespaces. + /// </summary> + public ISet<string> Namespaces { get; private set; } + + /// <summary> + /// Gets the template resolver. + /// </summary> + public ITemplateResolver Resolver { get; private set; } + #endregion + + #region Methods + /// <summary> + /// Adds the namespaces from the specified collection. + /// </summary> + /// <param name="namespaces">The set of namespace configurations.</param> + private void AddNamespaces(NamespaceConfigurationElementCollection namespaces) + { + if (namespaces == null || namespaces.Count == 0) + return; + + foreach (NamespaceConfigurationElement config in namespaces) + Namespaces.Add(config.Namespace); + } + + /// <summary> + /// Gets an instance of the specified type. + /// </summary> + /// <typeparam name="T">The expected instance type.</typeparam> + /// <param name="type">The type.</param> + /// <returns>The instance.</returns> + private T GetInstance<T>(Type type) + { + Type instanceType = typeof(T); + + if (!instanceType.IsAssignableFrom(type)) + throw new ConfigurationErrorsException("The type '" + type.FullName + "' is not assignable to type '" + instanceType.FullName + "'"); + + return (T)System.Activator.CreateInstance(type); + } + + /// <summary> + /// Gets the type with the specified name. + /// </summary> + /// <param name="typeName">The type name.</param> + /// <returns></returns> + private Type GetType(string typeName) + { + if (string.IsNullOrWhiteSpace(typeName)) + return null; + + var type = Type.GetType(typeName); + if (type == null) + throw new ConfigurationErrorsException("The type '" + typeName + "' could not be loaded."); + + return type; + } + + /// <summary> + /// Initialises the configuration. + /// </summary> + /// <param name="name">The name of the template service configuration.</param> + private void InitialiseConfiguration(string name) + { + var config = RazorEngineConfigurationSection.GetConfiguration(); + if (config == null) + throw new ConfigurationErrorsException("No <razorEngine> configuration section has been defined."); + + var serviceConfig = config.TemplateServices + .OfType<TemplateServiceConfigurationElement>() + .Where(t => t.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) + .SingleOrDefault(); + + if (serviceConfig == null) + throw new ConfigurationErrorsException("No <templateService> configuration element defined with name = '" + name + "'"); + + InitialiseConfiguration(config, serviceConfig); + } + + /// <summary> + /// Initialises the configuration. + /// </summary> + /// <param name="config">The core configuration.</param> + /// <param name="serviceConfig">The service configuration.</param> + private void InitialiseConfiguration(RazorEngineConfigurationSection config, TemplateServiceConfigurationElement serviceConfig) + { + // Set whether we are allowing missing properties on dynamic. + AllowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic; + + // Add the global namespaces. + AddNamespaces(config.Namespaces); + + // Add the specific namespaces. + AddNamespaces(serviceConfig.Namespaces); + + // Sets the activator. + SetActivator(config.ActivatorType); + + // Sets the base template type. + SetBaseTemplateType(serviceConfig.BaseTemplateType); + + // Sets the compiler service factory. + SetCompilerServiceFactory(config.CompilerServiceFactoryType); + + Debug = serviceConfig.Debug; + + // Sets the encoded string factory. + SetEncodedStringFactory(serviceConfig.EncodedStringFactoryType); + + // Set the language. + Language = serviceConfig.Language; + + // Sets the tempalte resolver. + SetTemplateResolver(config.TemplateResolverType); + } + + /// <summary> + /// Sets the activator. + /// </summary> + /// <param name="activatorType">The activator type.</param> + private void SetActivator(string activatorType) + { + var type = GetType(activatorType); + if (type != null) + Activator = GetInstance<IActivator>(type); + } + + /// <summary> + /// Sets the base template type. + /// </summary> + /// <param name="baseTemplateType">The base template type.</param> + private void SetBaseTemplateType(string baseTemplateType) + { + var type = GetType(baseTemplateType); + if (type != null) + BaseTemplateType = type; + } + + /// <summary> + /// Sets the compiler service factory. + /// </summary> + /// <param name="compilerServiceFactoryType">The compiler service factory type.</param> + private void SetCompilerServiceFactory(string compilerServiceFactoryType) + { + var type = GetType(compilerServiceFactoryType); + if (type != null) + CompilerServiceFactory = GetInstance<ICompilerServiceFactory>(type); + } + + /// <summary> + /// Sets the encoded string factory. + /// </summary> + /// <param name="encodedStringFactoryType"></param> + private void SetEncodedStringFactory(string encodedStringFactoryType) + { + var type = GetType(encodedStringFactoryType); + if (type != null) + EncodedStringFactory = GetInstance<IEncodedStringFactory>(type); + } + + /// <summary> + /// Sets the template resolver. + /// </summary> + /// <param name="templateResolverType">The template resolver type.</param> + private void SetTemplateResolver(string templateResolverType) + { + var type = GetType(templateResolverType); + if (type != null) + Resolver = GetInstance<ITemplateResolver>(type); + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Encoding.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,18 @@ +namespace RazorEngine +{ + /// <summary> + /// Defines the possible values for encoding. + /// </summary> + public enum Encoding + { + /// <summary> + /// Use html encoding. + /// </summary> + Html, + + /// <summary> + /// Use raw text (no encoding) + /// </summary> + Raw + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Language.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,18 @@ +namespace RazorEngine +{ + /// <summary> + /// Defines the possible supported code languages. + /// </summary> + public enum Language + { + /// <summary> + /// C# Language + /// </summary> + CSharp, + + /// <summary> + /// Visual Basic Language + /// </summary> + VisualBasic + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/PositionTagged.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,67 @@ +using RazorEngine.Common; + +namespace RazorEngine +{ + using System; + using System.Diagnostics; + + [DebuggerDisplay("({Position})\"{Value}\"")] + public class PositionTagged<T> + { + private PositionTagged() + { + Position = 0; + Value = default(T); + } + + public PositionTagged(T value, int offset) + { + Position = offset; + Value = value; + } + + public int Position { get; private set; } + public T Value { get; private set; } + + public override bool Equals(object obj) + { + PositionTagged<T> other = obj as PositionTagged<T>; + return other != null && + other.Position == Position && + Equals(other.Value, Value); + } + + public override int GetHashCode() + { + return HashCodeCombiner.Start() + .Add(Position) + .Add(Value) + .CombinedHash; + } + + public override string ToString() + { + return Value.ToString(); + } + + public static implicit operator T(PositionTagged<T> value) + { + return value.Value; + } + + public static implicit operator PositionTagged<T>(Tuple<T, int> value) + { + return new PositionTagged<T>(value.Item1, value.Item2); + } + + public static bool operator ==(PositionTagged<T> left, PositionTagged<T> right) + { + return Equals(left, right); + } + + public static bool operator !=(PositionTagged<T> left, PositionTagged<T> right) + { + return !Equals(left, right); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Properties/AssemblyInfo.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,20 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("RazorEngine.Core")] +[assembly: AssemblyDescription("RazorEngine - Core Framework")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("c11064c2-11b8-420b-81f0-4c6477cb5931")] + +// Allow the test assembly access to internals. +[assembly: InternalsVisibleTo("RazorEngine.Core.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100ad3b3604eb9ba317840ece0a65ec22fa67ee54cb4abb5148f184a90d9e9cdbc77c098fe3447ce9e13ef73d3e046016e7053f4c5c0ccd9f521514200dd09aa12cedc63bf39c30eb0516ac6b42bb645dfd41902290a87ceaf0309a9f08bfdd9cceb27b6186bfbe68ca91dca2508820c0723b0e4d94f3ef8049b8aa3f524d4715ca")]
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Razor.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,622 @@ +namespace RazorEngine +{ + using System; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + using System.Linq; + + using Templating; + + /// <summary> + /// Provides quick access to template functions. + /// </summary> + public static class Razor + { + #region Fields + private static ITemplateService _service = new TemplateService(); + private static readonly object _sync = new object(); + #endregion + + #region Properties + /// <summary> + /// Gets the template service. + /// </summary> + private static ITemplateService TemplateService + { + get + { + lock (_sync) + return _service; + } + } + #endregion + + #region Methods + /// <summary> + /// Compiles the specified template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="cacheName">The name of the template type in cache.</param> + public static void Compile(string razorTemplate, string cacheName) + { + TemplateService.Compile(razorTemplate, null, cacheName); + } + + /// <summary> + /// Compiles the specified template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type.</param> + /// <param name="cacheName">The name of the template type in cache.</param> + public static void Compile(string razorTemplate, Type modelType, string cacheName) + { + TemplateService.Compile(razorTemplate, modelType, cacheName); + } + + /// <summary> + /// Compiles the specified template. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="cacheName">The name of the template type in cache.</param> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "We already provide a non-generic alternative.")] + public static void Compile<T>(string razorTemplate, string cacheName) + { + TemplateService.Compile(razorTemplate, typeof(T), cacheName); + } + + /// <summary> + /// Creates an instance of <see cref="ITemplate"/> from the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + public static ITemplate CreateTemplate(string razorTemplate) + { + return TemplateService.CreateTemplate(razorTemplate, null, null); + } + + /// <summary> + /// Creates an instance of <see cref="ITemplate{T}"/> from the specified string template. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <returns>An instance of <see cref="ITemplate{T}"/>.</returns> + public static ITemplate CreateTemplate<T>(string razorTemplate, T model) + { + return TemplateService.CreateTemplate(razorTemplate, null, model); + } + + /// <summary> + /// Creates a set of templates from the specified string templates. + /// </summary> + /// <param name="razorTemplates">The set of templates to create <see cref="ITemplate"/> instances for.</param> + /// <param name="parallel">Flag to determine whether to create templates in parallel.</param> + /// <returns>The enumerable set of template instances.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<ITemplate> CreateTemplates(IEnumerable<string> razorTemplates, bool parallel = false) + { + return TemplateService.CreateTemplates(razorTemplates, null, null, parallel); + } + + /// <summary> + /// Creates a set of templates from the specified string templates and models. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplates">The set of templates to create <see cref="ITemplate"/> instances for.</param> + /// <param name="models">The set of models used to assign to templates.</param> + /// <param name="parallel">Flag to determine whether to create templates in parallel.</param> + /// <returns>The enumerable set of template instances.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<ITemplate> CreateTemplates<T>(IEnumerable<string> razorTemplates, IEnumerable<T> models, bool parallel = false) + { + List<object> modelList = (from m in models select (object)m).ToList(); + return TemplateService.CreateTemplates(razorTemplates, null, modelList, parallel); + } + + /// <summary> + /// Creates a <see cref="Type"/> that can be used to instantiate an instance of a template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <returns>An instance of <see cref="Type"/>.</returns> + public static Type CreateTemplateType(string razorTemplate) + { + return TemplateService.CreateTemplateType(razorTemplate, null); + } + + /// <summary> + /// Creates a <see cref="Type"/> that can be used to instantiate an instance of a template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type.</param> + /// <returns>An instance of <see cref="Type"/>.</returns> + public static Type CreateTemplateType(string razorTemplate, Type modelType) + { + return TemplateService.CreateTemplateType(razorTemplate, modelType); + } + + /// <summary> + /// Crates a set of template types from the specfied string templates. + /// </summary> + /// <param name="razorTemplates">The set of templates to create <see cref="Type"/> instances for.</param> + /// <param name="parallel">Flag to determine whether to create template types in parallel.</param> + /// <returns>The set of <see cref="Type"/> instances.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<Type> CreateTemplateTypes(IEnumerable<string> razorTemplates, bool parallel = false) + { + return TemplateService.CreateTemplateTypes(razorTemplates, null, parallel); + } + + /// <summary> + /// Creates a set of template types from the specfied string templates. + /// </summary> + /// <param name="razorTemplates">The set of templates to create <see cref="Type"/> instances for.</param> + /// <param name="modelType">The model type.</param> + /// <param name="parallel">Flag to determine whether to create template types in parallel.</param> + /// <returns>The set of <see cref="Type"/> instances.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<Type> CreateTemplateTypes(IEnumerable<string> razorTemplates, Type modelType, bool parallel = false) + { + IEnumerable<Type> modelTypes = Enumerable.Repeat<Type>(modelType, razorTemplates.Count()); + return TemplateService.CreateTemplateTypes(razorTemplates, modelTypes, parallel); + } + + /// <summary> + /// Gets an instance of the template using the cached compiled type, or compiles the template type + /// if it does not exist in the cache. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + public static ITemplate GetTemplate(string razorTemplate, string cacheName) + { + return TemplateService.GetTemplate(razorTemplate, null, cacheName); + } + + /// <summary> + /// Gets an instance of the template using the cached compiled type, or compiles the template type + /// if it does not exist in the cache. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + /// <returns>An instance of <see cref="ITemplate{T}"/>.</returns> + public static ITemplate GetTemplate<T>(string razorTemplate, T model, string cacheName) + { + return TemplateService.GetTemplate(razorTemplate, model, cacheName); + } + + /// <summary> + /// Gets the set of template instances for the specified string templates. Cached templates will be considered + /// and if they do not exist, new types will be created and instantiated. + /// </summary> + /// <param name="razorTemplates">The set of templates to create.</param> + /// <param name="cacheNames">The set of cache names.</param> + /// <param name="parallel">Flag to determine whether to get the templates in parallel.</param> + /// <returns>The set of <see cref="ITemplate"/> instances.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<ITemplate> GetTemplates(IEnumerable<string> razorTemplates, IEnumerable<string> cacheNames, bool parallel = false) + { + return TemplateService.GetTemplates(razorTemplates, null, cacheNames, parallel); + } + + /// <summary> + /// Gets the set of template instances for the specified string templates. Cached templates will be considered + /// and if they do not exist, new types will be created and instantiated. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplates">The set of templates to create.</param> + /// <param name="models">The set of models.</param> + /// <param name="cacheNames">The set of cache names.</param> + /// <param name="parallel">Flag to determine whether to get the templates in parallel.</param> + /// <returns>The set of <see cref="ITemplate"/> instances.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<ITemplate> GetTemplates<T>(IEnumerable<string> razorTemplates, IEnumerable<T> models, IEnumerable<string> cacheNames, bool parallel = false) + { + List<object> modelList = (from m in models select (object)m).ToList(); + return TemplateService.GetTemplates(razorTemplates, modelList, cacheNames, parallel); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <returns>The string result of the template.</returns> + public static string Parse(string razorTemplate) + { + return TemplateService.Parse(razorTemplate, null, null, null); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// This method will provide a cache check to see if the compiled template type already exists and is valid. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + public static string Parse(string razorTemplate, string cacheName) + { + return TemplateService.Parse(razorTemplate, null, null, cacheName); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <returns>The string result of the template.</returns> + public static string Parse(string razorTemplate, object model) + { + return TemplateService.Parse(razorTemplate, model, null, null); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <returns>The string result of the template.</returns> + public static string Parse<T>(string razorTemplate, T model) + { + return TemplateService.Parse(razorTemplate, model, null, null); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + public static string Parse<T>(string razorTemplate, T model, string cacheName) + { + return TemplateService.Parse(razorTemplate, model, null, cacheName); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + public static string Parse<T>(string razorTemplate, T model, DynamicViewBag viewBag, string cacheName) + { + return TemplateService.Parse(razorTemplate, model, viewBag, cacheName); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + public static string Parse(string razorTemplate, object model, string cacheName) + { + return TemplateService.Parse(razorTemplate, model, null, cacheName); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + public static string Parse(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName) + { + return TemplateService.Parse(razorTemplate, model, viewBag, cacheName); + } + + /// <summary> + /// Parses the template and merges with the many models provided. + /// </summary> + /// <param name="razorTemplate">The razor template.</param> + /// <param name="models"> + /// The set of models (must contain at least one model). + /// </param> + /// <param name="parallel">Flag to determine whether parsing in parallel.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany(string razorTemplate, IEnumerable<object> models, bool parallel = false) + { + if (models == null) + throw new ArgumentException("Expected models list (this parameter may not be NULL)."); + + if (models.Count() == 0) + throw new ArgumentException("Expected at least one entry in models list."); + + List<string> razorTemplateList = Enumerable.Repeat(razorTemplate, models.Count()).ToList(); + return TemplateService.ParseMany(razorTemplateList, models, null, null, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, bool parallel = false) + { + return TemplateService.ParseMany(razorTemplates, null, null, null, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<object> models, bool parallel = false) + { + return TemplateService.ParseMany(razorTemplates, models, null, null, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for templates. + /// Individual elements in this set may be NULL if caching is not desired for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<string> cacheNames, bool parallel = false) + { + return TemplateService.ParseMany(razorTemplates, null, null, cacheNames, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for templates. + /// Individual elements in this set may be NULL if caching is not desired for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<string> cacheNames, bool parallel = false) + { + return TemplateService.ParseMany(razorTemplates, models, null, cacheNames, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="viewBags"> + /// The set of initial ViewBag contents or NULL for an initially empty ViewBag for all templates. + /// Individual elements in this set may be NULL if an initially empty ViewBag is desired for a specific template. + /// </param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for templates. + /// Individual elements in this set may be NULL if caching is not desired for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<DynamicViewBag> viewBags, IEnumerable<string> cacheNames, bool parallel = false) + { + return TemplateService.ParseMany(razorTemplates, models, viewBags, cacheNames, parallel); + } + + /// <summary> + /// Parses the template and merges with the many models provided. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplate">The razor template.</param> + /// <param name="models"> + /// The set of models (must contain at least one model). + /// </param> + /// <param name="parallel">Flag to determine whether parsing in parallel.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany<T>(string razorTemplate, IEnumerable<T> models, bool parallel = false) + { + if (models == null) + throw new ArgumentException("Expected models list (this parameter may not be NULL)."); + + if (models.Count() == 0) + throw new ArgumentException("Expected at least one entry in models list."); + + List<string> razorTemplateList = Enumerable.Repeat(razorTemplate, models.Count()).ToList(); + List<object> modelList = (from m in models select (object)m).ToList(); + return TemplateService.ParseMany(razorTemplateList, modelList, null, null, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany<T>(IEnumerable<string> razorTemplates, IEnumerable<T> models, bool parallel = false) + { + List<object> modelList = (from m in models select (object)m).ToList(); + return TemplateService.ParseMany(razorTemplates, modelList, null, null, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for templates. + /// Individual elements in this set may be NULL if caching is not desired for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany<T>(IEnumerable<string> razorTemplates, IEnumerable<T> models, IEnumerable<string> cacheNames, bool parallel = false) + { + List<object> modelList = (from m in models select (object)m).ToList(); + return TemplateService.ParseMany(razorTemplates, modelList, null, cacheNames, parallel); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="viewBags"> + /// The set of initial ViewBag contents or NULL for an initially empty ViewBag for all templates. + /// Individual elements in this set may be NULL if an initially empty ViewBag is desired for a specific template. + /// </param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for templates. + /// Individual elements in this set may be NULL if caching is not desired for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")] + public static IEnumerable<string> ParseMany<T>(IEnumerable<string> razorTemplates, IEnumerable<T> models, IEnumerable<DynamicViewBag> viewBags, IEnumerable<string> cacheNames, bool parallel = false) + { + List<object> modelList = (from m in models select (object)m).ToList(); + return TemplateService.ParseMany(razorTemplates, modelList, viewBags, cacheNames, parallel); + } + + /// <summary> + /// Resolves the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>The resolved template.</returns> + public static ITemplate Resolve(string cacheName) + { + return TemplateService.Resolve(cacheName, null); + } + + /// <summary> + /// Resolves the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model for the template.</param> + /// <returns>The resolved template.</returns> + public static ITemplate Resolve(string cacheName, object model) + { + return TemplateService.Resolve(cacheName, model); + } + + /// <summary> + /// Resolves the template with the specified name. + /// </summary> + /// <typeparam name="T"></typeparam> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model for the template.</param> + /// <returns>The resolved template.</returns> + public static ITemplate Resolve<T>(string cacheName, T model) + { + return TemplateService.Resolve(cacheName, model); + } + + /// <summary> + /// Runs the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>The string result of the template.</returns> + public static string Run(string cacheName) + { + return TemplateService.Run(cacheName, null, null); + } + + /// <summary> + /// Runs the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model.</param> + /// <returns>The string result of the template.</returns> + public static string Run(string cacheName, object model) + { + return TemplateService.Run(cacheName, model, null); + } + + /// <summary> + /// Runs the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + public static string Run(string cacheName, object model, DynamicViewBag viewBag) + { + return TemplateService.Run(cacheName, model, viewBag); + } + + /// <summary> + /// Runs the template with the specified name. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model.</param> + /// <returns>The string result of the template.</returns> + public static string Run<T>(string cacheName, T model) + { + return TemplateService.Run(cacheName, model, null); + } + + /// <summary> + /// Runs the template with the specified name. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + public static string Run<T>(string cacheName, T model, DynamicViewBag viewBag) + { + return TemplateService.Run(cacheName, model, viewBag); + } + + /// <summary> + /// Sets the template service. + /// </summary> + /// <param name="service">The template service.</param> + public static void SetTemplateService(ITemplateService service) + { + Contract.Requires(service != null); + + lock (_sync) + _service = service; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/RazorEngine.Core.csproj Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,175 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>8.0.30703</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>RazorEngine</RootNamespace> + <AssemblyName>RazorEngine</AssemblyName> + <TargetFrameworkVersion>v4.5</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <CodeContractsAssemblyMode>1</CodeContractsAssemblyMode> + <TargetFrameworkProfile /> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>TRACE;DEBUG</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking> + <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface> + <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure> + <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires> + <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis> + <CodeContractsNonNullObligations>True</CodeContractsNonNullObligations> + <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations> + <CodeContractsArithmeticObligations>True</CodeContractsArithmeticObligations> + <CodeContractsRedundantAssumptions>True</CodeContractsRedundantAssumptions> + <CodeContractsRunInBackground>True</CodeContractsRunInBackground> + <CodeContractsShowSquigglies>True</CodeContractsShowSquigglies> + <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine> + <CodeContractsEmitXMLDocs>True</CodeContractsEmitXMLDocs> + <CodeContractsCustomRewriterAssembly /> + <CodeContractsCustomRewriterClass /> + <CodeContractsLibPaths /> + <CodeContractsExtraRewriteOptions /> + <CodeContractsExtraAnalysisOptions /> + <CodeContractsBaseLineFile>..\..\baseline.xml</CodeContractsBaseLineFile> + <CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults> + <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel> + <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly> + <DocumentationFile>bin\Debug\RazorEngine.XML</DocumentationFile> + <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet> + <RunCodeAnalysis>false</RunCodeAnalysis> + <Prefer32Bit>false</Prefer32Bit> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + <Prefer32Bit>false</Prefer32Bit> + <DocumentationFile>bin\Release\RazorEngine.XML</DocumentationFile> + </PropertyGroup> + <PropertyGroup> + <SignAssembly>true</SignAssembly> + </PropertyGroup> + <PropertyGroup> + <AssemblyOriginatorKeyFile>RazorEngine.snk</AssemblyOriginatorKeyFile> + </PropertyGroup> + <ItemGroup> + <Reference Include="System" /> + <Reference Include="System.Configuration" /> + <Reference Include="System.Core" /> + <Reference Include="Microsoft.CSharp" /> + <Reference Include="System.Web.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\packages\Microsoft.AspNet.Razor.3.0.0\lib\net45\System.Web.Razor.dll</HintPath> + </Reference> + </ItemGroup> + <ItemGroup> + <Compile Include="..\..\Shared\SharedAssemblyInfo.cs"> + <Link>Properties\SharedAssemblyInfo.cs</Link> + </Compile> + <Compile Include="AttributeValue.cs" /> + <Compile Include="CodeGenerators\SetModelTypeCodeGenerator.cs" /> + <Compile Include="Compilation\CompilerServiceBase.cs" /> + <Compile Include="Compilation\CompilerServiceBuilder.cs" /> + <Compile Include="Compilation\CompilerServicesUtility.cs" /> + <Compile Include="Compilation\CSharp\CSharpCodeParser.cs" /> + <Compile Include="Compilation\CSharp\CSharpDirectCompilerService.cs" /> + <Compile Include="Compilation\CSharp\CSharpRazorCodeGenerator.cs" /> + <Compile Include="Compilation\CSharp\CSharpRazorCodeLanguage.cs" /> + <Compile Include="Compilation\DefaultCompilerServiceFactory.cs" /> + <Compile Include="Compilation\DirectCompilerServiceBase.cs" /> + <Compile Include="Compilation\HasDynamicModelAttribute.cs" /> + <Compile Include="Compilation\Inspectors\ICodeInspector.cs" /> + <Compile Include="Compilation\ICompilerService.cs" /> + <Compile Include="Compilation\ICompilerServiceFactory.cs" /> + <Compile Include="Compilation\RazorDynamicObject.cs" /> + <Compile Include="Compilation\RazorEngineHost.cs" /> + <Compile Include="Compilation\TypeContext.cs" /> + <Compile Include="Compilation\VisualBasic\VBCodeParser.cs" /> + <Compile Include="Compilation\VisualBasic\VBDirectCompilerService.cs" /> + <Compile Include="Compilation\VisualBasic\VBRazorCodeGenerator.cs" /> + <Compile Include="Compilation\VisualBasic\VBRazorCodeLanguage.cs" /> + <Compile Include="Configuration\TemplateServiceConfiguration.cs" /> + <Compile Include="Configuration\Fluent\FluentConfigurationBuilder.cs" /> + <Compile Include="Configuration\Fluent\FluentTemplateServiceConfiguration.cs" /> + <Compile Include="Configuration\Fluent\IConfigurationBuilder.cs" /> + <Compile Include="Configuration\ITemplateServiceConfiguration.cs" /> + <Compile Include="Configuration\RazorEngineConfigurationSection.cs" /> + <Compile Include="Configuration\Xml\NamespaceConfigurationElement.cs" /> + <Compile Include="Configuration\Xml\NamespaceConfigurationElementCollection.cs" /> + <Compile Include="Configuration\Xml\TemplateServiceConfigurationElement.cs" /> + <Compile Include="Configuration\Xml\TemplateServiceConfigurationElementCollection.cs" /> + <Compile Include="Configuration\Xml\XmlTemplateServiceConfiguration.cs" /> + <Compile Include="Encoding.cs" /> + <Compile Include="Common\GlobalSuppressions.cs" /> + <Compile Include="Common\HashCodeCombiner.cs" /> + <Compile Include="Language.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="PositionTagged.cs" /> + <Compile Include="Razor.cs" /> + <Compile Include="Templating\CachedTemplateItem.cs" /> + <Compile Include="Templating\HtmlTemplateBaseOfT.cs" /> + <Compile Include="Templating\DefaultActivator.cs" /> + <Compile Include="Templating\DefaultAppDomainFactory.cs" /> + <Compile Include="Templating\DelegateActivator.cs" /> + <Compile Include="Templating\DelegateAppDomainFactory.cs" /> + <Compile Include="Templating\DelegateTemplateResolver.cs" /> + <Compile Include="Templating\DynamicViewBag.cs" /> + <Compile Include="Templating\ExecuteContext.cs" /> + <Compile Include="Templating\IActivator.cs" /> + <Compile Include="Templating\IAppDomainFactory.cs" /> + <Compile Include="Templating\InstanceContext.cs" /> + <Compile Include="Templating\ITemplateResolver.cs" /> + <Compile Include="Templating\Parallel\DefaultParallelQueryPlan.cs" /> + <Compile Include="Templating\Parallel\IParallelQueryPlan.cs" /> + <Compile Include="Templating\IsolatedTemplateService.cs" /> + <Compile Include="Templating\ITemplate.cs" /> + <Compile Include="Templating\ITemplateOfT.cs" /> + <Compile Include="Templating\ITemplateService.cs" /> + <Compile Include="Templating\RequireNamespacesAttribute.cs" /> + <Compile Include="Templating\TemplateBase.cs" /> + <Compile Include="Templating\TemplateBaseOfT.cs" /> + <Compile Include="Templating\TemplateCompilationException.cs" /> + <Compile Include="Templating\TemplateServiceFactory.cs" /> + <Compile Include="Templating\TypeLoader.cs" /> + <Compile Include="Templating\TemplateParsingException.cs" /> + <Compile Include="Templating\TemplateService.cs" /> + <Compile Include="Templating\TemplateWriter.cs" /> + <Compile Include="Text\HtmlEncodedString.cs" /> + <Compile Include="Text\HtmlEncodedStringFactory.cs" /> + <Compile Include="Text\IEncodedString.cs" /> + <Compile Include="Text\IEncodedStringFactory.cs" /> + <Compile Include="Text\RawString.cs" /> + <Compile Include="Text\RawStringFactory.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="ClassDiagram.cd" /> + <None Include="packages.config" /> + <None Include="RazorEngine.snk" /> + </ItemGroup> + <ItemGroup /> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <PropertyGroup> + <PostBuildEvent>xcopy "$(TargetDir)RazorEngine.*" "$(SolutionDir)..\nuget\lib\net45" /y</PostBuildEvent> + </PropertyGroup> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/CachedTemplateItem.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,35 @@ +namespace RazorEngine.Templating +{ + using System; + + /// <summary> + /// Defines a cached template item. + /// </summary> + internal class CachedTemplateItem + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="CachedTemplateItem"/>. + /// </summary> + /// <param name="cachedHashCode">The cached hash code.</param> + /// <param name="templateType">The template type.</param> + public CachedTemplateItem(int cachedHashCode, Type templateType) + { + CachedHashCode = cachedHashCode; + TemplateType = templateType; + } + #endregion + + #region Properties + /// <summary> + /// Gets the cached hash code of the template. + /// </summary> + public int CachedHashCode { get; private set; } + + /// <summary> + /// Gets the template type. + /// </summary> + public Type TemplateType { get; private set; } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/DefaultActivator.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,27 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics.Contracts; + + /// <summary> + /// Provides a default implementation of an <see cref="IActivator"/>. + /// </summary> + internal class DefaultActivator : IActivator + { + #region Methods + /// <summary> + /// Creates an instance of the specifed template. + /// </summary> + /// <param name="context">The instance context.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + [Pure] + public ITemplate CreateInstance(InstanceContext context) + { + if (context == null) + throw new ArgumentNullException("context"); + + return context.Loader.CreateInstance(context.TemplateType); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/DefaultAppDomainFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,24 @@ +namespace RazorEngine.Templating +{ + using System; + + /// <summary> + /// Provides a default implementation of an <see cref="AppDomain"/> factory. + /// </summary> + public class DefaultAppDomainFactory : IAppDomainFactory + { + #region Methods + /// <summary> + /// Creates the <see cref="AppDomain"/>. + /// </summary> + /// <returns>The <see cref="AppDomain"/> instance.</returns> + public AppDomain CreateAppDomain() + { + var current = AppDomain.CurrentDomain; + var domain = AppDomain.CreateDomain("RazorHost", current.Evidence, current.SetupInformation); + + return domain; + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/DelegateActivator.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,48 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics.Contracts; + + /// <summary> + /// Defines an activator that supports delegated activation. + /// </summary> + internal class DelegateActivator : IActivator + { + #region Fields + private readonly Func<InstanceContext, ITemplate> _activator; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="DelegateActivator"/>. + /// </summary> + /// <param name="activator">The delegated used to create an instance of the template.</param> + public DelegateActivator(Func<InstanceContext, ITemplate> activator) + { + Contract.Requires(activator != null); + + _activator = activator; + } + #endregion + + #region Properties + /// <summary> + /// Gets the activator. + /// </summary> + internal Func<InstanceContext, ITemplate> Activator { get { return _activator; } } + #endregion + + #region Methods + /// <summary> + /// Creates an instance of the specifed template. + /// </summary> + /// <param name="context">The instance context.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + [Pure] + public ITemplate CreateInstance(InstanceContext context) + { + return _activator(context); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/DelegateAppDomainFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,39 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics.Contracts; + + /// <summary> + /// Provides an <see cref="AppDomain"/> factory that supports delegated <see cref="AppDomain"/> creation. + /// </summary> + internal class DelegateAppDomainFactory : IAppDomainFactory + { + #region Fields + private readonly Func<AppDomain> _factory; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="DelegateAppDomainFactory"/>. + /// </summary> + /// <param name="factory">The factory delegate.</param> + public DelegateAppDomainFactory(Func<AppDomain> factory) + { + Contract.Requires(factory != null); + + _factory = factory; + } + #endregion + + #region Methods + /// <summary> + /// Creates the <see cref="AppDomain"/>. + /// </summary> + /// <returns>The <see cref="AppDomain"/> instance.</returns> + public AppDomain CreateAppDomain() + { + return _factory(); + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/DelegateTemplateResolver.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,40 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics.Contracts; + + /// <summary> + /// Provides an <see cref="ITemplateResolver"/> that supports delegated template resolution. + /// </summary> + public class DelegateTemplateResolver : ITemplateResolver + { + #region Fields + private readonly Func<string, string> _resolver; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="DelegateTemplateResolver"/>. + /// </summary> + /// <param name="resolver">The resolver delegate.</param> + public DelegateTemplateResolver(Func<string, string> resolver) + { + Contract.Requires(resolver != null); + + _resolver = resolver; + } + #endregion + + #region Methods + /// <summary> + /// Resolves the template content with the specified name. + /// </summary> + /// <param name="name">The name of the template to resolve.</param> + /// <returns>The template content.</returns> + public string Resolve(string name) + { + return _resolver(name); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/DynamicViewBag.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,202 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Dynamic; + + /// <summary> + /// Defines a dynamic view bag. + /// </summary> + public class DynamicViewBag : DynamicObject + { + #region Fields + private readonly IDictionary<string, object> _dict = new Dictionary<string, object>(); + #endregion + + /// <summary> + /// Initialises a new instance of <see cref="DynamicViewBag"/> + /// </summary> + /// <param name="viewbag">The parent view bag.</param> + public DynamicViewBag(DynamicViewBag viewbag = null) + { + if (viewbag != null) + { + // Add the viewbag to the current dictionary. + foreach (var pair in viewbag._dict) + _dict.Add(pair); + } + } + + #region DynamicObject Overrides + + /// <summary> + /// Gets the set of dynamic member names. + /// </summary> + /// <returns>An instance of <see cref="IEnumerable{String}"/>.</returns> + public override IEnumerable<string> GetDynamicMemberNames() + { + return _dict.Keys; + } + + /// <summary> + /// Attempts to read a dynamic member from the object. + /// </summary> + /// <param name="binder">The binder.</param> + /// <param name="result">The result instance.</param> + /// <returns>True, always.</returns> + public override bool TryGetMember(GetMemberBinder binder, out object result) + { + if (_dict.ContainsKey(binder.Name)) + result = _dict[binder.Name]; + else + result = null; + + return true; + } + + /// <summary> + /// Attempts to set a value on the object. + /// </summary> + /// <param name="binder">The binder.</param> + /// <param name="value">The value to set.</param> + /// <returns>True, always.</returns> + public override bool TrySetMember(SetMemberBinder binder, object value) + { + if (_dict.ContainsKey(binder.Name)) + _dict[binder.Name] = value; + else + _dict.Add(binder.Name, value); + + return true; + } + + #endregion + + #region Helper Methods + + /// <summary> + /// Set a value in this instance of DynamicViewBag. + /// </summary> + /// <param name="propertyName"> + /// The property name through which this value can be get/set. + /// </param> + /// <param name="value"> + /// The value that will be assigned to this property name. + /// </param> + public void SetValue(string propertyName, object value) + { + if (propertyName == null) + throw new ArgumentNullException("The propertyName parameter may not be NULL."); + + _dict[propertyName] = value; + } + + /// <summary> + /// Add a value to this instance of DynamicViewBag. + /// </summary> + /// <param name="propertyName"> + /// The property name through which this value can be get/set. + /// </param> + /// <param name="value"> + /// The value that will be assigned to this property name. + /// </param> + public void AddValue(string propertyName, object value) + { + if (propertyName == null) + throw new ArgumentNullException("The propertyName parameter may not be NULL."); + + if (_dict.ContainsKey(propertyName) == true) + throw new ArgumentException("Attempt to add duplicate value for the '" + propertyName + "' property."); + + _dict.Add(propertyName, value); + } + + /// <summary> + /// Adds values from the specified valueList to this instance of DynamicViewBag. + /// </summary> + /// <param name="valueList"> + /// A list of objects. Each must have a public property of keyPropertyName. + /// </param> + /// <param name="keyPropertyName"> + /// The property name that will be retrieved for each object in the specified valueList + /// and used as the key (property name) for the ViewBag. This property must be of type string. + /// </param> + public void AddListValues(IList valueList, string keyPropertyName) + { + foreach (object value in valueList) + { + if (value == null) + throw new ArgumentNullException("Invalid NULL value in initializer list."); + + Type type = value.GetType(); + object objKey = type.GetProperty(keyPropertyName); + + if (objKey.GetType() != typeof(string)) + throw new ArgumentNullException("The keyPropertyName property must be of type string."); + + string strKey = (string)objKey; + + if (_dict.ContainsKey(strKey) == true) + throw new ArgumentException("Attempt to add duplicate value for the '" + strKey + "' property."); + + _dict.Add(strKey, value); + } + } + + /// <summary> + /// Adds values from the specified valueDictionary to this instance of DynamicViewBag. + /// </summary> + /// <param name="valueDictionary"> + /// A dictionary of objects. The Key of each item in the dictionary will be used + /// as the key (property name) for the ViewBag. + /// </param> + public void AddDictionaryValues(IDictionary valueDictionary) + { + foreach (object objKey in valueDictionary.Keys) + { + if (objKey.GetType() != typeof(string)) + throw new ArgumentNullException("The Key in valueDictionary must be of type string."); + + string strKey = (string)objKey; + + if (_dict.ContainsKey(strKey) == true) + throw new ArgumentException("Attempt to add duplicate value for the '" + strKey + "' property."); + + object value = valueDictionary[strKey]; + + _dict.Add(strKey, value); + } + } + + /// <summary> + /// Adds values from the specified valueDictionary to this instance of DynamicViewBag. + /// </summary> + /// <param name="valueDictionary"> + /// A generic dictionary of {string, object} objects. The Key of each item in the + /// dictionary will be used as the key (property name) for the ViewBag. + /// </param> + /// <remarks> + /// This method was intentionally not overloaded from AddDictionaryValues due to an ambiguous + /// signature when the caller passes in a Dictionary<string, object> as the valueDictionary. + /// This is because the Dictionary<TK, TV>() class implements both IDictionary and IDictionary<TK, TV>. + /// A Dictionary<string, ???> (any other type than object) will resolve to AddDictionaryValues. + /// This is specifically for a generic List<string, object>, which does not resolve to + /// an IDictionary interface. + /// </remarks> + public void AddDictionaryValuesEx(IDictionary<string, object> valueDictionary) + { + foreach (string strKey in valueDictionary.Keys) + { + if (_dict.ContainsKey(strKey) == true) + throw new ArgumentException("Attempt to add duplicate value for the '" + strKey + "' property."); + + object value = valueDictionary[strKey]; + + _dict.Add(strKey, value); + } + } + + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/ExecuteContext.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,108 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Collections.Generic; + using System.Dynamic; + using System.IO; + + /// <summary> + /// Defines a context for tracking template execution. + /// </summary> + public class ExecuteContext + { + #region Constructors + + /// <summary> + /// Creates a new instance of ExecuteContext with an empty ViewBag. + /// </summary> + public ExecuteContext() + { + _viewBag = new DynamicViewBag(); + } + + /// <summary> + /// Creates a new instance of DynamicViewBag, setting initial values in the ViewBag. + /// </summary> + /// <param name="viewBag">The initial view bag data or NULL for an empty ViewBag.</param> + public ExecuteContext(DynamicViewBag viewBag) + { + if (viewBag == null) + _viewBag = new DynamicViewBag(); + else + _viewBag = viewBag; + } + + #endregion + + #region Fields + private readonly IDictionary<string, Action> _definedSections = new Dictionary<string, Action>(); + private readonly Stack<TemplateWriter> _bodyWriters = new Stack<TemplateWriter>(); + private readonly dynamic _viewBag; + #endregion + + #region Properties + /// <summary> + /// Gets the current writer. + /// </summary> + //internal TextWriter CurrentWriter { get { return _writers.Peek(); } } + internal TextWriter CurrentWriter { get; set; } + + /// <summary> + /// Gets the viewbag that allows sharing state. + /// </summary> + public dynamic ViewBag { get { return _viewBag; } } + #endregion + + #region Methods + /// <summary> + /// Defines a section used in layouts. + /// </summary> + /// <param name="name">The name of the section.</param> + /// <param name="action">The delegate action used to write the section at a later stage in the template execution.</param> + public void DefineSection(string name, Action action) + { + if (string.IsNullOrWhiteSpace(name)) + throw new ArgumentException("A name is required to define a section."); + + if (_definedSections.ContainsKey(name)) + throw new ArgumentException("A section has already been defined with name '" + name + "'"); + + _definedSections.Add(name, action); + } + + /// <summary> + /// Gets the section delegate. + /// </summary> + /// <param name="name">The name of the section.</param> + /// <returns>The section delegate.</returns> + public Action GetSectionDelegate(string name) + { + if (_definedSections.ContainsKey(name)) + return _definedSections[name]; + + return null; + } + + /// <summary> + /// Pops the template writer helper off the stack. + /// </summary> + /// <returns>The template writer helper.</returns> + internal TemplateWriter PopBody() + { + return _bodyWriters.Pop(); + } + + /// <summary> + /// Pushes the specified template writer helper onto the stack. + /// </summary> + /// <param name="bodyWriter">The template writer helper.</param> + internal void PushBody(TemplateWriter bodyWriter) + { + if (bodyWriter == null) + throw new ArgumentNullException("bodyWriter"); + + _bodyWriters.Push(bodyWriter); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/HtmlTemplateBaseOfT.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,15 @@ +namespace RazorEngine.Templating +{ + using System.Diagnostics; + using System.IO; + + /// <summary> + /// Provides a base implementation of an html template with a model. + /// </summary> + /// <remarks> + /// This type does not currently serve a purpose, and the WriteAttribute* API has been migrated to the TemplateBase type. This type is not deprecated, as it + /// may form the basis for a future template that supports MVC like @Html syntax. + /// </remarks> + /// <typeparam name="T">The model type.</typeparam> + public class HtmlTemplateBase<T> : TemplateBase<T> { } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/IActivator.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,17 @@ +namespace RazorEngine.Templating +{ + /// <summary> + /// Defines the required contract for implementing an activator. + /// </summary> + public interface IActivator + { + #region Methods + /// <summary> + /// Creates an instance of the specifed template. + /// </summary> + /// <param name="context">The instance context.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + ITemplate CreateInstance(InstanceContext context); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/IAppDomainFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,18 @@ +namespace RazorEngine.Templating +{ + using System; + + /// <summary> + /// Defines the required contract for implementing an <see cref="AppDomain"/> factory. + /// </summary> + public interface IAppDomainFactory + { + #region Methods + /// <summary> + /// Creates the <see cref="AppDomain"/>. + /// </summary> + /// <returns>The <see cref="AppDomain"/> instance.</returns> + AppDomain CreateAppDomain(); + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/ITemplate.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,41 @@ +namespace RazorEngine.Templating +{ + /// <summary> + /// Defines the required contract for implementing a template. + /// </summary> + public interface ITemplate + { + #region Properties + /// <summary> + /// Sets the template service. + /// </summary> + ITemplateService TemplateService { set; } + #endregion + + #region Methods + /// <summary> + /// Executes the compiled template. + /// </summary> + void Execute(); + + /// <summary> + /// Runs the template and returns the result. + /// </summary> + /// <param name="context">The current execution context.</param> + /// <returns>The merged result of the template.</returns> + string Run(ExecuteContext context); + + /// <summary> + /// Writes the specified object to the result. + /// </summary> + /// <param name="value">The value to write.</param> + void Write(object value); + + /// <summary> + /// Writes the specified string to the result. + /// </summary> + /// <param name="literal">The literal to write.</param> + void WriteLiteral(string literal); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/ITemplateOfT.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,16 @@ +namespace RazorEngine.Templating +{ + /// <summary> + /// Defines the required contract for implementing a template with a model. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + public interface ITemplate<T> : ITemplate + { + #region Properties + /// <summary> + /// Gets the or sets the model. + /// </summary> + T Model { get; set; } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/ITemplateResolver.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,17 @@ +namespace RazorEngine.Templating +{ + /// <summary> + /// Defines the required contract for implementing a template resolver. + /// </summary> + public interface ITemplateResolver + { + #region Methods + /// <summary> + /// Resolves the template content with the specified name. + /// </summary> + /// <param name="name">The name of the template to resolve.</param> + /// <returns>The template content.</returns> + string Resolve(string name); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/ITemplateService.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,210 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Collections.Generic; + + using Configuration; + using Text; + + /// <summary> + /// Defines the required contract for implementing a template service. + /// </summary> + public interface ITemplateService : IDisposable + { + #region Properties + /// <summary> + /// Gets the template service configuration. + /// </summary> + ITemplateServiceConfiguration Configuration { get; } + + /// <summary> + /// Gets the encoded string factory. + /// </summary> + IEncodedStringFactory EncodedStringFactory { get; } + #endregion + + #region Methods + /// <summary> + /// Adds a namespace that will be imported into the template. + /// </summary> + /// <param name="ns">The namespace to be imported.</param> + void AddNamespace(string ns); + + /// <summary> + /// Creates a new <see cref="ExecuteContext"/> used to tracking templates. + /// </summary> + /// <param name="viewBag">The view bag.</param> + /// <returns>The instance of <see cref="ExecuteContext"/></returns> + ExecuteContext CreateExecuteContext(DynamicViewBag viewBag = null); + + /// <summary> + /// Compiles the specified template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + void Compile(string razorTemplate, Type modelType, string cacheName); + + /// <summary> + /// Creates an instance of <see cref="ITemplate{T}"/> from the specified string template. + /// </summary> + /// <param name="razorTemplate"> + /// The string template. + /// If templateType is not NULL (precompiled template), this parameter may be NULL (unused). + /// </param> + /// <param name="templateType"> + /// The template type or NULL if the template type should be dynamically created. + /// If razorTemplate is not NULL, this parameter may be NULL (unused). + /// </param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <returns>An instance of <see cref="ITemplate{T}"/>.</returns> + ITemplate CreateTemplate(string razorTemplate, Type templateType, object model); + + /// <summary> + /// Creates a set of templates from the specified string templates. + /// </summary> + /// <param name="razorTemplates"> + /// The set of templates to create or NULL if all template types are already created (see templateTypes). + /// If this parameter is NULL, the the templateTypes parameter may not be NULL. + /// Individual elements in this set may be NULL if the corresponding templateTypes[i] is not NULL (precompiled template). + /// </param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="templateTypes"> + /// The set of template types or NULL to dynamically create template types for each template. + /// If this parameter is NULL, the the razorTemplates parameter may not be NULL. + /// Individual elements in this set may be NULL to dynamically create the template if the corresponding razorTemplates[i] is not NULL (dynamically compile template). + /// </param> + /// <param name="parallel">Flag to determine whether to create templates in parallel.</param> + /// <returns>The enumerable set of template instances.</returns> + IEnumerable<ITemplate> CreateTemplates(IEnumerable<string> razorTemplates, IEnumerable<Type> templateTypes, IEnumerable<object> models, bool parallel = false); + + /// <summary> + /// Creates a <see cref="Type"/> that can be used to instantiate an instance of a template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type or NULL if no model exists.</param> + /// <returns>An instance of <see cref="Type"/>.</returns> + Type CreateTemplateType(string razorTemplate, Type modelType); + + /// <summary> + /// Creates a set of template types from the specfied string templates. + /// </summary> + /// <param name="razorTemplates">The set of templates to create <see cref="Type"/> instances for.</param> + /// <param name="modelTypes"> + /// The set of model types or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether to create template types in parallel.</param> + /// <returns>The set of <see cref="Type"/> instances.</returns> + IEnumerable<Type> CreateTemplateTypes(IEnumerable<string> razorTemplates, IEnumerable<Type> modelTypes, bool parallel = false); + + /// <summary> + /// Gets an instance of the template using the cached compiled type, or compiles the template type + /// if it does not exist in the cache. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model or NULL if there is no model for this template.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + ITemplate GetTemplate(string razorTemplate, object model, string cacheName); + + /// <summary> + /// Gets the set of template instances for the specified string templates. Cached templates will be considered + /// and if they do not exist, new types will be created and instantiated. + /// </summary> + /// <param name="razorTemplates">The set of templates to create.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="cacheNames">The set of cache names.</param> + /// <param name="parallel">Flag to determine whether to get the templates in parallel.</param> + /// <returns>The set of <see cref="ITemplate"/> instances.</returns> + IEnumerable<ITemplate> GetTemplates(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<string> cacheNames, bool parallel = false); + + /// <summary> + /// Returns whether or not a template by the specified name has been created already. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>Whether or not the template has been created.</returns> + bool HasTemplate(string cacheName); + + /// <summary> + /// Remove a template by the specified name from the cache. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>Whether or not the template has been removed.</returns> + bool RemoveTemplate(string cacheName); + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + string Parse(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName); + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <typeparam name="T">Type of the model. Used to find out the type of the model, if model is NULL</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + string Parse<T>(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName); + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="viewBags"> + /// The set of initial ViewBag contents or NULL for an initially empty ViewBag for all templates. + /// Individual elements in this set may be NULL if an initially empty ViewBag is desired for a specific template. + /// </param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for templates. + /// Individual elements in this set may be NULL if caching is not desired for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<DynamicViewBag> viewBags, IEnumerable<string> cacheNames, bool parallel); + + /// <summary> + /// Resolves the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model for the template.</param> + /// <returns>The resolved template.</returns> + ITemplate Resolve(string cacheName, object model); + + /// <summary> + /// Runs the template with the specified cacheName. + /// </summary> + /// <param name="cacheName">The name of the template in cache. The template must be in cache.</param> + /// <param name="model">The model for the template or NULL if there is no model.</param> + /// <param name="viewBag">The initial ViewBag contents NULL for an empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + string Run(string cacheName, object model, DynamicViewBag viewBag); + + /// <summary> + /// Runs the specified template. + /// </summary> + /// <param name="template">The template to run.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + string Run(ITemplate template, DynamicViewBag viewBag); + + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/InstanceContext.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,39 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics.Contracts; + + /// <summary> + /// Defines contextual information for a template instance. + /// </summary> + public class InstanceContext + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="InstanceContext"/>. + /// </summary> + /// <param name="loader">The type loader.</param> + /// <param name="templateType">The template type.</param> + internal InstanceContext(TypeLoader loader, Type templateType) + { + Contract.Requires(loader != null); + Contract.Requires(templateType != null); + + Loader = loader; + TemplateType = templateType; + } + #endregion + + #region Properties + /// <summary> + /// Gets the type loader. + /// </summary> + public TypeLoader Loader { get; private set; } + + /// <summary> + /// Gets the template type. + /// </summary> + public Type TemplateType { get; private set; } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/IsolatedTemplateService.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,493 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Collections.Generic; + using System.Globalization; + using System.Reflection; + using System.Linq; + + using Compilation; + using Configuration; + using Text; + + /// <summary> + /// Provides template parsing and compilation in an isolated application domain. + /// </summary> + public class IsolatedTemplateService : ITemplateService + { + #region Fields + private static readonly Type TemplateServiceType = typeof(TemplateService); + private readonly ITemplateService _proxy; + private readonly AppDomain _appDomain; + private bool disposed; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/> + /// </summary> + public IsolatedTemplateService() + : this(Language.CSharp, Encoding.Html, (IAppDomainFactory)null) { } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/> + /// </summary> + /// <param name="language">The code language.</param> + public IsolatedTemplateService(Language language) + : this(language, Encoding.Html, (IAppDomainFactory)null) { } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/> + /// </summary> + /// <param name="encoding">The encoding.</param> + public IsolatedTemplateService(Encoding encoding) + : this(Language.CSharp, encoding, (IAppDomainFactory)null) { } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/> + /// </summary> + /// <param name="appDomainFactory">The application domain factory.</param> + public IsolatedTemplateService(IAppDomainFactory appDomainFactory) + : this(Language.CSharp, Encoding.Html, appDomainFactory) { } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/>. + /// </summary> + /// <param name="appDomainFactory">The delegate used to create an application domain.</param> + public IsolatedTemplateService(Func<AppDomain> appDomainFactory) + : this(Language.CSharp, Encoding.Html, appDomainFactory) { } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/> + /// </summary> + /// <param name="language">The code language.</param> + /// <param name="encoding">The encoding.</param> + /// <param name="appDomainFactory">The application domain factory.</param> + public IsolatedTemplateService(Language language, Encoding encoding, IAppDomainFactory appDomainFactory) + { + _appDomain = CreateAppDomain(appDomainFactory ?? new DefaultAppDomainFactory()); + + string assemblyName = TemplateServiceType.Assembly.FullName; + string typeName = TemplateServiceType.FullName; + + _proxy = (ITemplateService)_appDomain.CreateInstance( + assemblyName, typeName, false, BindingFlags.NonPublic | BindingFlags.Instance, + null, new object[] { language, encoding }, CultureInfo.CurrentCulture, null).Unwrap(); + } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/>. + /// </summary> + /// <param name="language">The code language.</param> + /// <param name="appDomainFactory">The delegate used to create an application domain.</param> + public IsolatedTemplateService(Language language, Func<AppDomain> appDomainFactory) + : this(language, Encoding.Html, new DelegateAppDomainFactory(appDomainFactory)) { } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/>. + /// </summary> + /// <param name="language">The code language.</param> + /// <param name="encoding">The encoding.</param> + /// <param name="appDomainFactory">The delegate used to create an application domain.</param> + public IsolatedTemplateService(Language language, Encoding encoding, Func<AppDomain> appDomainFactory) + : this(language, encoding, new DelegateAppDomainFactory(appDomainFactory)) { } + + /// <summary> + /// Initialises a new instance of <see cref="IsolatedTemplateService"/>. + /// </summary> + /// <param name="encoding">The encoding.</param> + /// <param name="appDomainFactory">The delegate used to create an application domain.</param> + public IsolatedTemplateService(Encoding encoding, Func<AppDomain> appDomainFactory) + : this(Language.CSharp, encoding, new DelegateAppDomainFactory(appDomainFactory)) { } + #endregion + + #region Properties + /// <summary> + /// Gets the template service configuration. + /// </summary> + ITemplateServiceConfiguration ITemplateService.Configuration { get { return null; } } + + /// <summary> + /// Gets the encoded string factory. + /// </summary> + IEncodedStringFactory ITemplateService.EncodedStringFactory { get { return null; } } + #endregion + + #region Methods + /// <summary> + /// Adds a namespace that will be imported into the template. + /// </summary> + /// <param name="ns">The namespace to be imported.</param> + public void AddNamespace(string ns) + { + _proxy.AddNamespace(ns); + } + + /// <summary> + /// Creates a new <see cref="ExecuteContext"/> used to tracking templates. + /// </summary> + /// <param name="viewBag">The view bag.</param> + /// <returns>The instance of <see cref="ExecuteContext"/></returns> + ExecuteContext ITemplateService.CreateExecuteContext(DynamicViewBag viewBag = null) + { + throw new NotSupportedException("This operation is not supported directly by the IsolatedTemplateService."); + } + + /// <summary> + /// Compiles the specified template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + public void Compile(string razorTemplate, Type modelType, string cacheName) + { + _proxy.Compile(razorTemplate, modelType, cacheName); + } + + /// <summary> + /// Creates an application domain. + /// </summary> + /// <param name="factory">The application domain factory.</param> + /// <returns>An instance of <see cref="AppDomain"/>.</returns> + private static AppDomain CreateAppDomain(IAppDomainFactory factory) + { + var domain = factory.CreateAppDomain(); + if (domain == null) + throw new InvalidOperationException("The application domain factory did not create an application domain."); + + if (domain == AppDomain.CurrentDomain) + throw new InvalidOperationException("The application domain factory returned the current application domain which cannot be used for isolation."); + + return domain; + } + + /// <summary> + /// Creates an instance of <see cref="ITemplate{T}"/> from the specified string template. + /// </summary> + /// <param name="razorTemplate"> + /// The string template. + /// If templateType is not NULL, this parameter may be NULL (unused). + /// </param> + /// <param name="templateType"> + /// The template type or NULL if the template type should be dynamically created. + /// If razorTemplate is not NULL, this parameter may be NULL (unused). + /// </param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <returns>An instance of <see cref="ITemplate{T}"/>.</returns> + public ITemplate CreateTemplate(string razorTemplate, Type templateType, object model) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if (model != null) + { + if (CompilerServicesUtility.IsDynamicType(model.GetType())) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + } + + return _proxy.CreateTemplate(razorTemplate, templateType, model); + } + + /// <summary> + /// Creates a set of templates from the specified string templates and models. + /// </summary> + /// <param name="razorTemplates"> + /// The set of templates to create or NULL if all template types are already created (see templateTypes). + /// If this parameter is NULL, the the templateTypes parameter may not be NULL. + /// Individual elements in this set may be NULL if the corresponding templateTypes[i] is not NULL (precompiled template). + /// </param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="templateTypes"> + /// The set of template types or NULL to dynamically create template types for each template. + /// If this parameter is NULL, the the razorTemplates parameter may not be NULL. + /// Individual elements in this set may be NULL to dynamically create the template if the corresponding razorTemplates[i] is not NULL (dynamically compile template). + /// </param> + /// <param name="parallel">Flag to determine whether to create templates in parallel.</param> + /// <returns>The enumerable set of template instances.</returns> + public IEnumerable<ITemplate> CreateTemplates(IEnumerable<string> razorTemplates, IEnumerable<Type> templateTypes, IEnumerable<object> models, bool parallel = false) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if (models != null) + { + foreach (object model in models) + { + if (model != null) + { + if (CompilerServicesUtility.IsDynamicType(model.GetType())) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + } + } + } + + return _proxy.CreateTemplates(razorTemplates, templateTypes, models, parallel); + } + + /// <summary> + /// Creates a <see cref="Type"/> that can be used to instantiate an instance of a template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type or NULL if no model exists.</param> + /// <returns>An instance of <see cref="Type"/>.</returns> + public Type CreateTemplateType(string razorTemplate, Type modelType) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if (CompilerServicesUtility.IsDynamicType(modelType)) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + + return _proxy.CreateTemplateType(razorTemplate, modelType); + } + + /// <summary> + /// Creates a set of template types from the specfied string templates. + /// </summary> + /// <param name="razorTemplates">The set of templates to create <see cref="Type"/> instances for.</param> + /// <param name="modelTypes"> + /// The set of model types or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether to create template types in parallel.</param> + /// <returns>The set of <see cref="Type"/> instances.</returns> + public IEnumerable<Type> CreateTemplateTypes(IEnumerable<string> razorTemplates, IEnumerable<Type> modelTypes, bool parallel = false) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if (modelTypes != null) + { + foreach (Type modelType in modelTypes) + { + if ((modelType != null) && CompilerServicesUtility.IsDynamicType(modelType)) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + } + } + + return _proxy.CreateTemplateTypes(razorTemplates, modelTypes, parallel); + } + + /// <summary> + /// Releases resources used by this instance. + /// </summary> + /// <remarks> + /// This method ensures the AppDomain is unloaded and any template assemblies are unloaded with it. + /// </remarks> + /// <param name="disposing">Flag to determine whether the instance is being disposed explicitly.</param> + protected virtual void Dispose(bool disposing) + { + if (disposing && !disposed) + { + _proxy.Dispose(); + + AppDomain.Unload(_appDomain); + disposed = true; + } + } + + /// <summary> + /// Releases resources used by this instance. + /// </summary> + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// <summary> + /// Gets an instance of the template using the cached compiled type, or compiles the template type + /// if it does not exist in the cache. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model or NULL if there is no model for this template.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + public ITemplate GetTemplate(string razorTemplate, object model, string cacheName) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + return _proxy.GetTemplate(razorTemplate, model, cacheName); + } + + /// <summary> + /// Gets the set of template instances for the specified string templates. Cached templates will be considered + /// and if they do not exist, new types will be created and instantiated. + /// </summary> + /// <param name="razorTemplates">The set of templates to create.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="cacheNames">The set of cache names.</param> + /// <param name="parallel">Flag to determine whether to get the templates in parallel.</param> + /// <returns>The set of <see cref="ITemplate"/> instances.</returns> + public IEnumerable<ITemplate> GetTemplates(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<string> cacheNames, bool parallel = false) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if (models != null) + { + foreach (object model in models) + { + if (model != null) + { + if (CompilerServicesUtility.IsDynamicType(model.GetType())) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + } + } + } + + return _proxy.GetTemplates(razorTemplates, models, cacheNames, parallel); + } + + /// <summary> + /// Returns whether or not a template by the specified name has been created already. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>Whether or not the template has been created.</returns> + public bool HasTemplate(string cacheName) + { + return _proxy.HasTemplate(cacheName); + } + + /// <summary> + /// Remove a template by the specified name from the cache. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>Whether or not the template has been removed.</returns> + public bool RemoveTemplate(string cacheName) + { + return _proxy.RemoveTemplate(cacheName); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + public string Parse(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if (model != null) + { + if (CompilerServicesUtility.IsDynamicType(model.GetType())) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + } + + return _proxy.Parse(razorTemplate, model, viewBag, cacheName); + } + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + public string Parse<T>(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if (model != null) + { + if (CompilerServicesUtility.IsDynamicType(model.GetType())) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + } + + return _proxy.Parse<T>(razorTemplate, model, viewBag, cacheName); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="viewBags"> + /// The set of initial ViewBag contents or NULL for an initially empty ViewBag for all templates. + /// Individual elements in this set may be NULL if an initially empty ViewBag is desired for a specific template. + /// </param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for all templates. + /// Individual elements in this set may be NULL if caching is not desired for specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in templates.</param> + /// <returns>The set of parsed template results.</returns> + public IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<DynamicViewBag> viewBags, IEnumerable<string> cacheNames, bool parallel) + { + if (disposed) + throw new ObjectDisposedException("IsolatedTemplateService"); + + if ((models != null) && (models.Count() != razorTemplates.Count())) + throw new ArgumentException("Expected same number of models contents as templates to be processed."); + + if ((viewBags != null) && (viewBags.Count() != razorTemplates.Count())) + throw new ArgumentException("Expected same number of ViewBag contents as templates to be processed."); + + if ((cacheNames != null) && (cacheNames.Count() != razorTemplates.Count())) + throw new ArgumentException("Expected same number of cache names as templates to be processed."); + + if (models != null) + { + foreach (object model in models) + { + if ((model != null) && CompilerServicesUtility.IsDynamicType(model.GetType())) + throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types."); + } + } + + return _proxy.ParseMany(razorTemplates, models, viewBags, cacheNames, parallel).ToList(); + } + + /// <summary> + /// Resolves the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model or NULL if there is no model for the template.</param> + /// <returns>The resolved template.</returns> + public ITemplate Resolve(string cacheName, object model) + { + return _proxy.Resolve(cacheName, model); + } + + /// <summary> + /// Runs the template with the specified cacheName. + /// </summary> + /// <param name="cacheName">The name of the template in cache. The template must be in cache.</param> + /// <param name="model">The model for the template or NULL if there is no model.</param> + /// <param name="viewBag">The initial ViewBag contents NULL for an empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + public string Run(string cacheName, object model, DynamicViewBag viewBag) + { + return _proxy.Run(cacheName, model, viewBag); + } + + /// <summary> + /// Runs the template with the specified name. + /// </summary> + /// <param name="template">The template to run.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + public string Run(ITemplate template, DynamicViewBag viewBag) + { + return _proxy.Run(template, viewBag); + } + + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/Parallel/DefaultParallelQueryPlan.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,28 @@ +namespace RazorEngine.Templating.Parallel +{ + using System.Collections.Generic; + using System.Linq; + + /// <summary> + /// Represents a default parallel query plan. + /// </summary> + /// <remarks> + /// The <see cref="DefaultParallelQueryPlan{T}"/> uses the default <see cref="ParallelQuery{T}" /> + /// result. The degree of parallelism by default is <code>Math.Min(ProcessorCount, 64)</code>. + /// </remarks> + /// <typeparam name="T">The item type.</typeparam> + public class DefaultParallelQueryPlan<T> : IParallelQueryPlan<T> + { + #region Methods + /// <summary> + /// Creates a parallel query for the specified source. + /// </summary> + /// <param name="source">The source enumerable.</param> + /// <returns>The parallel query.</returns> + public ParallelQuery<T> CreateQuery(IEnumerable<T> source) + { + return source.AsParallel().AsOrdered(); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/Parallel/IParallelQueryPlan.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,21 @@ +namespace RazorEngine.Templating.Parallel +{ + using System.Collections.Generic; + using System.Linq; + + /// <summary> + /// Defines the required contract for implementing a parallel query plan. + /// </summary> + /// <typeparam name="T">The item type.</typeparam> + public interface IParallelQueryPlan<T> + { + #region Methods + /// <summary> + /// Creates a parallel query for the specified source. + /// </summary> + /// <param name="source">The source enumerable.</param> + /// <returns>The parallel query.</returns> + ParallelQuery<T> CreateQuery(IEnumerable<T> source); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/RequireNamespacesAttribute.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,38 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Collections.Generic; + + /// <summary> + /// Allows base templates to define require template imports when + /// generating templates. + /// </summary> + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)] + public sealed class RequireNamespacesAttribute : Attribute + { + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="RequireNamespacesAttribute"/>. + /// </summary> + /// <param name="namespaces">The set of required namespace imports.</param> + public RequireNamespacesAttribute(params string[] namespaces) + { + if (namespaces == null) + throw new ArgumentNullException("namespaces"); + + var set = new HashSet<string>(); + foreach (string ns in namespaces) + set.Add(ns); + + Namespaces = set; + } + #endregion + + #region Properties + /// <summary> + /// Gets the set of required namespace imports. + /// </summary> + public IEnumerable<string> Namespaces { get; private set; } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TemplateBase.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,365 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics; + using System.Diagnostics.Contracts; + using System.IO; + using System.Text; + + using Text; + + /// <summary> + /// Provides a base implementation of a template. + /// </summary> + public abstract class TemplateBase : MarshalByRefObject, ITemplate + { + #region Fields + protected ExecuteContext _context; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="TemplateBase"/>. + /// </summary> + protected TemplateBase() { } + #endregion + + #region Properties + /// <summary> + /// Gets or sets the layout template name. + /// </summary> + public string Layout { get; set; } + + /// <summary> + /// Gets or sets the template service. + /// </summary> + public ITemplateService TemplateService { get; set; } + + /// <summary> + /// Gets the viewbag that allows sharing state between layout and child templates. + /// </summary> + public dynamic ViewBag { get { return _context.ViewBag; } } + + /// <summary> + /// Gets the current writer. + /// </summary> + public TextWriter CurrentWriter { get { return _context.CurrentWriter; } } + #endregion + + #region Methods + /// <summary> + /// Defines a section that can written out to a layout. + /// </summary> + /// <param name="name">The name of the section.</param> + /// <param name="action">The delegate used to write the section.</param> + public void DefineSection(string name, Action action) + { + _context.DefineSection(name, action); + } + + /// <summary> + /// Includes the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model or NULL if there is no model for the template.</param> + /// <returns>The template writer helper.</returns> + public virtual TemplateWriter Include(string cacheName, object model = null) + { + var instance = TemplateService.Resolve(cacheName, model); + if (instance == null) + throw new ArgumentException("No template could be resolved with name '" + cacheName + "'"); + + return new TemplateWriter(tw => + tw.Write(instance.Run( + TemplateService.CreateExecuteContext(ViewBag)))); + } + + /// <summary> + /// Determines if the section with the specified name has been defined. + /// </summary> + /// <param name="name">The section name.</param> + /// <returns></returns> + public virtual bool IsSectionDefined(string name) + { + if (string.IsNullOrWhiteSpace(name)) + throw new ArgumentException("The name of the section to render must be specified."); + + return (_context.GetSectionDelegate(name) != null); + } + + /// <summary> + /// Executes the compiled template. + /// </summary> + public virtual void Execute() { } + + /// <summary> + /// Returns the specified string as a raw string. This will ensure it is not encoded. + /// </summary> + /// <param name="rawString">The raw string to write.</param> + /// <returns>An instance of <see cref="IEncodedString"/>.</returns> + public IEncodedString Raw(string rawString) + { + return new RawString(rawString); + } + + /// <summary> + /// Resolves the layout template. + /// </summary> + /// <param name="name">The name of the layout template.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + protected virtual ITemplate ResolveLayout(string name) + { + return TemplateService.Resolve(name, null); + } + + /// <summary> + /// Runs the template and returns the result. + /// </summary> + /// <param name="context">The current execution context.</param> + /// <returns>The merged result of the template.</returns> + string ITemplate.Run(ExecuteContext context) + { + _context = context; + + var builder = new StringBuilder(); + using (var writer = new StringWriter(builder)) + { + _context.CurrentWriter = writer; + Execute(); + _context.CurrentWriter = null; + } + + if (Layout != null) + { + // Get the layout template. + var layout = ResolveLayout(Layout); + + if (layout == null) + { + throw new ArgumentException("Template you are trying to run uses layout, but no layout found in cache or by resolver."); + } + + // Push the current body instance onto the stack for later execution. + var body = new TemplateWriter(tw => tw.Write(builder.ToString())); + context.PushBody(body); + + return layout.Run(context); + } + + return builder.ToString(); + } + + /// <summary> + /// Renders the section with the specified name. + /// </summary> + /// <param name="name">The name of the section.</param> + /// <param name="isRequired">Flag to specify whether the section is required.</param> + /// <returns>The template writer helper.</returns> + public virtual TemplateWriter RenderSection(string name, bool isRequired = true) + { + if (string.IsNullOrWhiteSpace(name)) + throw new ArgumentException("The name of the section to render must be specified."); + + var action = _context.GetSectionDelegate(name); + if (action == null && isRequired) + throw new ArgumentException("No section has been defined with name '" + name + "'"); + + if (action == null) action = () => { }; + + return new TemplateWriter(tw => action()); + } + + /// <summary> + /// Renders the body of the template. + /// </summary> + /// <returns>The template writer helper.</returns> + public TemplateWriter RenderBody() + { + return _context.PopBody(); + } + + /// <summary> + /// Writes the specified object to the result. + /// </summary> + /// <param name="value">The value to write.</param> + public virtual void Write(object value) + { + WriteTo(_context.CurrentWriter, value); + } + + /// <summary> + /// Writes the specified template helper result. + /// </summary> + /// <param name="helper">The template writer helper.</param> + public virtual void Write(TemplateWriter helper) + { + if (helper == null) + return; + + helper.WriteTo(_context.CurrentWriter); + } + + /// <summary> + /// Writes an attribute to the result. + /// </summary> + /// <param name="name">The name of the attribute.</param> + public virtual void WriteAttribute(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) + { + WriteAttributeTo(CurrentWriter, name, prefix, suffix, values); + } + + /// <summary> + /// Writes an attribute to the specified <see cref="TextWriter"/>. + /// </summary> + /// <param name="writer">The writer.</param> + /// <param name="name">The name of the attribute to be written.</param> + public virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) + { + bool first = true; + bool wroteSomething = false; + if (values.Length == 0) + { + // Explicitly empty attribute, so write the prefix and suffix + WritePositionTaggedLiteral(writer, prefix); + WritePositionTaggedLiteral(writer, suffix); + } + else + { + for (int i = 0; i < values.Length; i++) + { + AttributeValue attrVal = values[i]; + PositionTagged<object> val = attrVal.Value; + + bool? boolVal = null; + if (val.Value is bool) + { + boolVal = (bool)val.Value; + } + + if (val.Value != null && (boolVal == null || boolVal.Value)) + { + string valStr = val.Value as string; + if (valStr == null) + { + valStr = val.Value.ToString(); + } + if (boolVal != null) + { + Debug.Assert(boolVal.Value); + valStr = name; + } + + if (first) + { + WritePositionTaggedLiteral(writer, prefix); + first = false; + } + else + { + WritePositionTaggedLiteral(writer, attrVal.Prefix); + } + + if (attrVal.Literal) + { + WriteLiteralTo(writer, valStr); + } + else + { + WriteTo(writer, valStr); // Write value + } + wroteSomething = true; + } + } + if (wroteSomething) + { + WritePositionTaggedLiteral(writer, suffix); + } + } + } + + /// <summary> + /// Writes the specified string to the result. + /// </summary> + /// <param name="literal">The literal to write.</param> + public virtual void WriteLiteral(string literal) + { + WriteLiteralTo(_context.CurrentWriter, literal); + } + + /// <summary> + /// Writes a string literal to the specified <see cref="TextWriter"/>. + /// </summary> + /// <param name="writer">The writer.</param> + /// <param name="literal">The literal to be written.</param> + public virtual void WriteLiteralTo(TextWriter writer, string literal) + { + if (writer == null) + throw new ArgumentNullException("writer"); + + if (literal == null) return; + writer.Write(literal); + } + + /// <summary> + /// Writes a <see cref="PositionTagged{string}" /> literal to the result. + /// </summary> + /// <param name="writer">The writer.</param> + /// <param name="literal">The literal to be written.</param> + private void WritePositionTaggedLiteral(TextWriter writer, PositionTagged<string> value) + { + WriteLiteralTo(writer, value.Value); + } + + /// <summary> + /// Writes the specified object to the specified <see cref="TextWriter"/>. + /// </summary> + /// <param name="writer">The writer.</param> + /// <param name="value">The value to be written.</param> + public virtual void WriteTo(TextWriter writer, object value) + { + if (writer == null) + throw new ArgumentNullException("writer"); + + if (value == null) return; + + var encodedString = value as IEncodedString; + if (encodedString != null) + { + writer.Write(encodedString); + } + else + { + encodedString = TemplateService.EncodedStringFactory.CreateEncodedString(value); + _context.CurrentWriter.Write(encodedString); + } + } + + /// <summary> + /// Writes the specfied template helper result to the specified writer. + /// </summary> + /// <param name="writer">The writer.</param> + /// <param name="helper">The template writer helper.</param> + public virtual void WriteTo(TextWriter writer, TemplateWriter helper) + { + if (helper == null) return; + + helper.WriteTo(writer); + } + + /// <summary> + /// Resolves the specified path + /// </summary> + /// <param name="path">The path.</param> + /// <returns>The resolved path.</returns> + public virtual string ResolveUrl(string path) + { + // TODO: Actually resolve the url + if (path.StartsWith("~")) + { + path = path.Substring(1); + } + return path; + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TemplateBaseOfT.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,82 @@ +namespace RazorEngine.Templating +{ + using System.Dynamic; + + using Compilation; + + /// <summary> + /// Provides a base implementation of a template with a model. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + public class TemplateBase<T> : TemplateBase, ITemplate<T> + { + #region Fields + + private object currentModel; + + #endregion + + #region Constructor + + /// <summary> + /// Initialises a new instance of <see cref="TemplateBase{T}"/>. + /// </summary> + protected TemplateBase() + { + HasDynamicModel = GetType().IsDefined(typeof (HasDynamicModelAttribute), true); + } + + #endregion + + #region Properties + + /// <summary> + /// Determines whether this template has a dynamic model. + /// </summary> + protected bool HasDynamicModel { get; private set; } + + /// <summary> + /// Gets or sets the model. + /// </summary> + public T Model + { + get { return (T)currentModel; } + set + { + if (HasDynamicModel && !(value is DynamicObject) && !(value is ExpandoObject)) + currentModel = new RazorDynamicObject + { + Model = value, + AllowMissingPropertiesOnDynamic = TemplateService.Configuration.AllowMissingPropertiesOnDynamic + }; + else + currentModel = value; + } + } + + #endregion + + /// <summary> + /// Includes the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model or NULL if there is no model for the template.</param> + /// <returns>The template writer helper.</returns> + public override TemplateWriter Include(string cacheName, object model = null) + { + return base.Include(cacheName, model ?? Model); + } + + #region Methods + /// <summary> + /// Resolves the layout template. + /// </summary> + /// <param name="name">The name of the layout template.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + protected override ITemplate ResolveLayout(string name) + { + return TemplateService.Resolve(name, (T)currentModel); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TemplateCompilationException.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,94 @@ +namespace RazorEngine.Templating +{ + using System; + using System.CodeDom.Compiler; + using System.Collections.Generic; + using System.Collections.ObjectModel; + using System.Diagnostics.CodeAnalysis; + using System.Linq; + using System.Runtime.Serialization; + + /// <summary> + /// Defines an exception that occurs during compilation of the template. + /// </summary> + [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors"), Serializable] + public class TemplateCompilationException : Exception + { + #region Constructors + /// <summary> + /// Initialises a new instance of <see cref="TemplateCompilationException"/>. + /// </summary> + /// <param name="errors">The set of compiler errors.</param> + /// <param name="sourceCode">The source code that wasn't compiled.</param> + /// <param name="template">The source template that wasn't compiled.</param> + internal TemplateCompilationException(CompilerErrorCollection errors, string sourceCode, string template) + : base("Unable to compile template. " + errors[0].ErrorText + "\n\nOther compilation errors may have occurred. Check the Errors property for more information.") + { + var list = errors.Cast<CompilerError>().ToList(); + Errors = new ReadOnlyCollection<CompilerError>(list); + SourceCode = sourceCode; + Template = template; + } + + /// <summary> + /// Initialises a new instance of <see cref="TemplateCompilationException"/> from serialised data. + /// </summary> + /// <param name="info">The serialisation info.</param> + /// <param name="context">The streaming context.</param> + protected TemplateCompilationException(SerializationInfo info, StreamingContext context) : base(info, context) + { + int count = info.GetInt32("Count"); + + var list = new List<CompilerError>(); + var type = typeof(CompilerError); + + for (int i = 0; i < count; i++) + { + list.Add((CompilerError)info.GetValue("Errors[" + i + "]", type)); + } + + Errors = new ReadOnlyCollection<CompilerError>(list); + + SourceCode = info.GetString("SourceCode"); + Template = info.GetString("Template"); + } + #endregion + + #region Properties + /// <summary> + /// Gets the set of compiler errors. + /// </summary> + public ReadOnlyCollection<CompilerError> Errors { get; private set; } + + /// <summary> + /// Gets the source code that wasn't compiled. + /// </summary> + public string SourceCode { get; private set; } + + /// <summary> + /// Gets the source template that wasn't compiled. + /// </summary> + public string Template { get; private set; } + #endregion + + #region Methods + /// <summary> + /// Gets the object data for serialisation. + /// </summary> + /// <param name="info">The serialisation info.</param> + /// <param name="context">The streaming context.</param> + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + + info.AddValue("Count", Errors.Count); + + for (int i = 0; i < Errors.Count; i++) + info.AddValue("Errors[" + i + "]", Errors[i]); + + info.AddValue("SourceCode", SourceCode ?? string.Empty); + info.AddValue("Template", Template ?? string.Empty); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TemplateParsingException.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,65 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics.CodeAnalysis; + using System.Runtime.Serialization; + using System.Web.Razor.Parser.SyntaxTree; + + /// <summary> + /// Defines an exception that occurs during template parsing. + /// </summary> + [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors"), Serializable] + public class TemplateParsingException : Exception + { + #region Constructors + /// <summary> + /// Initialises a new instance of <see cref="TemplateParsingException"/>. + /// </summary> + /// <param name="error">The <see cref="RazorError"/> generated by the parser.</param> + internal TemplateParsingException(RazorError error) + : base(error.Message) + { + Column = error.Location.CharacterIndex; + Line = error.Location.LineIndex; + } + + /// <summary> + /// Initialises a new instance of <see cref="TemplateParsingException"/> from serialised data. + /// </summary> + /// <param name="info">The serialisation info.</param> + /// <param name="context">The streaming context.</param> + protected TemplateParsingException(SerializationInfo info, StreamingContext context) : base(info, context) + { + Column = info.GetInt32("Column"); + Line = info.GetInt32("Line"); + } + #endregion + + #region Properties + /// <summary> + /// Gets the column the parsing error occured. + /// </summary> + public int Column { get; private set; } + + /// <summary> + /// Gets the line the parsing error occured. + /// </summary> + public int Line { get; private set; } + #endregion + + #region Methods + /// <summary> + /// Gets the object data for serialisation. + /// </summary> + /// <param name="info">The serialisation info.</param> + /// <param name="context">The streaming context.</param> + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + + info.AddValue("Column", Column); + info.AddValue("Line", Line); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TemplateService.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,677 @@ +using System.Runtime.Remoting.Contexts; + +namespace RazorEngine.Templating +{ + using System; + using System.Collections.Concurrent; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + using System.Linq; + using System.Reflection; + + using Compilation; + using Compilation.Inspectors; + using Configuration; + using Parallel; + using Text; + + /// <summary> + /// Defines a template service. + /// </summary> + public class TemplateService : MarshalByRefObject, ITemplateService + { + #region Fields + private readonly ITemplateServiceConfiguration _config; + + private readonly ConcurrentDictionary<string, CachedTemplateItem> _cache = new ConcurrentDictionary<string, CachedTemplateItem>(); + private readonly ConcurrentBag<Assembly> _assemblies = new ConcurrentBag<Assembly>(); + + private readonly TypeLoader _loader; + private static readonly Type _objectType = typeof(object); + + private bool disposed; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="TemplateService"/> + /// </summary> + /// <param name="config">The template service configuration.</param> + public TemplateService(ITemplateServiceConfiguration config) + { + Contract.Requires(config != null); + + _config = config; + _loader = new TypeLoader(AppDomain.CurrentDomain, _assemblies); + } + + /// <summary> + /// Initialises a new instance of <see cref="TemplateService"/>. + /// </summary> + public TemplateService() + : this(new TemplateServiceConfiguration()) { } + + /// <summary> + /// Initialises a new instance of <see cref="TemplateService"/> + /// </summary> + /// <param name="language">The code language.</param> + /// <param name="encoding">the encoding.</param> + internal TemplateService(Language language, Encoding encoding) + : this(new TemplateServiceConfiguration() { Language = language, EncodedStringFactory = GetEncodedStringFactory(encoding) }) { } + #endregion + + #region Properties + /// <summary> + /// Gets the template service configuration. + /// </summary> + public ITemplateServiceConfiguration Configuration { get { return _config; } } + + /// <summary> + /// Gets the encoded string factory. + /// </summary> + public IEncodedStringFactory EncodedStringFactory { get { return _config.EncodedStringFactory; } } + #endregion + + #region Methods + /// <summary> + /// Adds a namespace that will be imported into the template. + /// </summary> + /// <param name="ns">The namespace to be imported.</param> + public void AddNamespace(string ns) + { + _config.Namespaces.Add(ns); + } + + /// <summary> + /// Compiles the specified template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + public void Compile(string razorTemplate, Type modelType, string cacheName) + { + Contract.Requires(razorTemplate != null); + Contract.Requires(cacheName != null); + + int hashCode = razorTemplate.GetHashCode(); + + Type type = CreateTemplateType(razorTemplate, modelType); + var item = new CachedTemplateItem(hashCode, type); + + _cache.AddOrUpdate(cacheName, item, (n, i) => item); + } + + /// <summary> + /// Creates a new <see cref="ExecuteContext"/> for tracking templates. + /// </summary> + /// <param name="viewBag">The dynamic view bag.</param> + /// <returns>The execute context.</returns> + public virtual ExecuteContext CreateExecuteContext(DynamicViewBag viewBag = null) + { + var context = new ExecuteContext(new DynamicViewBag(viewBag)); + + return context; + } + + /// <summary> + /// Creates a new <see cref="InstanceContext"/> for creating template instances. + /// </summary> + /// <param name="templateType">The template type.</param> + /// <returns>An instance of <see cref="InstanceContext"/>.</returns> + [Pure] + protected virtual InstanceContext CreateInstanceContext(Type templateType) + { + return new InstanceContext(_loader, templateType); + } + + /// <summary> + /// Creates an instance of <see cref="ITemplate"/> from the specified string template. + /// </summary> + /// <param name="razorTemplate"> + /// The string template. + /// If templateType is not NULL, this parameter may be NULL (unused). + /// </param> + /// <param name="templateType"> + /// The template type or NULL if the template type should be dynamically created. + /// If razorTemplate is not NULL, this parameter may be NULL (unused). + /// </param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + [Pure] + public virtual ITemplate CreateTemplate(string razorTemplate, Type templateType, object model) + { + if (templateType == null) + { + Type modelType = (model == null) ? typeof(object) : model.GetType(); + templateType = CreateTemplateType(razorTemplate, modelType); + } + + var context = CreateInstanceContext(templateType); + ITemplate instance = _config.Activator.CreateInstance(context); + instance.TemplateService = this; + + SetModel(instance, model); + + return instance; + } + + /// <summary> + /// Creates a set of templates from the specified string templates and models. + /// </summary> + /// <param name="razorTemplates"> + /// The set of templates to create or NULL if all template types are already created (see templateTypes). + /// If this parameter is NULL, the the templateTypes parameter may not be NULL. + /// Individual elements in this set may be NULL if the corresponding templateTypes[i] is not NULL (precompiled template). + /// </param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="templateTypes"> + /// The set of template types or NULL to dynamically create template types for each template. + /// If this parameter is NULL, the the razorTemplates parameter may not be NULL. + /// Individual elements in this set may be NULL to dynamically create the template if the corresponding razorTemplates[i] is not NULL (dynamically compile template). + /// </param> + /// <param name="parallel">Flag to determine whether to create templates in parallel.</param> + /// <returns>The enumerable set of template instances.</returns> + [Pure] + public virtual IEnumerable<ITemplate> CreateTemplates(IEnumerable<string> razorTemplates, IEnumerable<Type> templateTypes, IEnumerable<object> models, bool parallel = false) + { + if ((razorTemplates == null) && (templateTypes == null)) + throw new ArgumentException("The razorTemplates and templateTypes parameters may not both be null."); + + List<string> razorTemplateList = (razorTemplates == null) ? null : razorTemplates.ToList(); + List<object> modelList = (models == null) ? null : models.ToList(); + List<Type> templateTypeList = (templateTypes == null) ? null : templateTypes.ToList(); + + int templateCount = (razorTemplateList != null) ? razorTemplateList.Count() : templateTypeList.Count(); + + if ((razorTemplateList != null) && (razorTemplateList.Count != templateTypeList.Count)) + throw new ArgumentException("Expected the same number of templateTypes as razorTemplates to be processed."); + + if ((templateTypeList != null) && (templateTypeList.Count != templateCount)) + throw new ArgumentException("Expected the same number of templateTypes as the number of templates to be processed."); + + if ((modelList != null) && (modelList.Count != templateCount)) + throw new ArgumentException("Expected the same number of models as the number of templates to be processed."); + + if ((razorTemplateList != null) && (templateTypeList != null)) + { + for (int i = 0; (i < templateCount); i++) + { + if (razorTemplateList == null) + { + if (templateTypeList[i] == null) + throw new ArgumentException("Expected non-NULL value in templateTypes[" + i.ToString() + "]."); + } + else if (templateTypeList == null) + { + if (razorTemplateList[i] == null) + throw new ArgumentException("Expected non-NULL value in either razorTemplates[" + i.ToString() + "]."); + } + else + { + if ((razorTemplateList[i] == null) && (templateTypeList[i] == null)) + throw new ArgumentException("Expected non-NULL value in either razorTemplates[" + i.ToString() + "] or templateTypes[" + i.ToString() + "]."); + } + } + } + + if (parallel) + { + if (razorTemplateList != null) + return GetParallelQueryPlan<string>() + .CreateQuery(razorTemplates) + .Select((rt, i) => CreateTemplate( + rt, + (templateTypeList == null) ? null : templateTypeList[i], + (modelList == null) ? null : modelList[i])); + else + return GetParallelQueryPlan<Type>() + .CreateQuery(templateTypes) + .Select((tt, i) => CreateTemplate( + (razorTemplateList == null) ? null : razorTemplateList[i], + tt, + (modelList == null) ? null : modelList[i])); + } + + if (razorTemplateList != null) + return razorTemplates.Select((rt, i) => CreateTemplate( + rt, + (templateTypeList == null) ? null : templateTypeList[i], + (modelList == null) ? null : modelList[i])); + else + return templateTypeList.Select((tt, i) => CreateTemplate( + (razorTemplateList == null) ? null : razorTemplateList[i], + tt, + (modelList == null) ? null : modelList[i])); + } + + /// <summary> + /// Creates a <see cref="Type"/> that can be used to instantiate an instance of a template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="modelType">The model type or NULL if no model exists.</param> + /// <returns>An instance of <see cref="Type"/>.</returns> + [Pure] + public virtual Type CreateTemplateType(string razorTemplate, Type modelType) + { + var context = new TypeContext + { + ModelType = (modelType == null) ? typeof(object) : modelType, + TemplateContent = razorTemplate, + TemplateType = (_config.BaseTemplateType) ?? typeof(TemplateBase<>) + }; + + foreach (string ns in _config.Namespaces) + context.Namespaces.Add(ns); + + var service = _config + .CompilerServiceFactory + .CreateCompilerService(_config.Language); + service.Debug = _config.Debug; + service.CodeInspectors = _config.CodeInspectors ?? Enumerable.Empty<ICodeInspector>(); + + var result = service.CompileType(context); + + _assemblies.Add(result.Item2); + + return result.Item1; + } + + /// <summary> + /// Creates a set of template types from the specfied string templates. + /// </summary> + /// <param name="razorTemplates">The set of templates to create <see cref="Type"/> instances for.</param> + /// <param name="modelTypes"> + /// The set of model types or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="parallel">Flag to determine whether to create template types in parallel.</param> + /// <returns>The set of <see cref="Type"/> instances.</returns> + [Pure] + public virtual IEnumerable<Type> CreateTemplateTypes(IEnumerable<string> razorTemplates, IEnumerable<Type> modelTypes, bool parallel = false) + { + Contract.Requires(razorTemplates != null); + + List<Type> modelTypeList = (modelTypes == null) ? null : modelTypes.ToList(); + + if (parallel) + return GetParallelQueryPlan<string>() + .CreateQuery(razorTemplates) + .Select((t, i) => CreateTemplateType(t, + (modelTypeList == null) ? null : modelTypeList[i])); + + return razorTemplates.Select((t, i) => CreateTemplateType(t, + (modelTypeList == null) ? null : modelTypeList[i])); + } + + /// <summary> + /// Releases managed resources used by this instance. + /// </summary> + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// <summary> + /// Releases managed resources used by this instance. + /// </summary> + /// <param name="disposing">Are we explicitly disposing of this instance?</param> + protected virtual void Dispose(bool disposing) + { + if (!disposed && disposing) + { + _loader.Dispose(); + disposed = true; + } + } + + /// <summary> + /// Gets an instance of a <see cref="IEncodedStringFactory"/> for a known encoding. + /// </summary> + /// <param name="encoding">The encoding to get a factory for.</param> + /// <returns>An instance of <see cref="IEncodedStringFactory"/></returns> + internal static IEncodedStringFactory GetEncodedStringFactory(Encoding encoding) + { + switch (encoding) + { + case Encoding.Html: + return new HtmlEncodedStringFactory(); + + case Encoding.Raw: + return new RawStringFactory(); + + default: + throw new ArgumentException("Unsupported encoding: " + encoding); + } + } + + /// <summary> + /// Gets a parellel query plan used to configure a parallel query. + /// </summary> + /// <typeparam name="T">The query item type.</typeparam> + /// <returns>An instance of <see cref="IParallelQueryPlan{T}"/>.</returns> + protected virtual IParallelQueryPlan<T> GetParallelQueryPlan<T>() + { + return new DefaultParallelQueryPlan<T>(); + } + + /// <summary> + /// Gets an instance of the template using the cached compiled type, or compiles the template type + /// if it does not exist in the cache. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if there is no model for this template.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + /// <returns>An instance of <see cref="ITemplate{T}"/>.</returns> + public virtual ITemplate GetTemplate(string razorTemplate, object model, string cacheName) + { + return this.GetTemplate<object>(razorTemplate, model, cacheName); + } + + /// <summary> + /// Gets an instance of the template using the cached compiled type, or compiles the template type + /// if it does not exist in the cache. + /// </summary> + /// <typeparam name="T">Type of the model</typeparam> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if there is no model for this template.</param> + /// <param name="cacheName">The name of the template type in the cache.</param> + /// <returns>An instance of <see cref="ITemplate{T}"/>.</returns> + private ITemplate GetTemplate<T>(string razorTemplate, object model, string cacheName) + { + if (razorTemplate == null) + throw new ArgumentNullException("razorTemplate"); + + int hashCode = razorTemplate.GetHashCode(); + + CachedTemplateItem item; + if (!(_cache.TryGetValue(cacheName, out item) && item.CachedHashCode == hashCode)) + { + Type type = CreateTemplateType(razorTemplate, (model == null) ? typeof(T) : model.GetType()); + item = new CachedTemplateItem(hashCode, type); + + _cache.AddOrUpdate(cacheName, item, (n, i) => item); + } + + var instance = CreateTemplate(null, item.TemplateType, model); + return instance; + } + + /// <summary> + /// Gets the set of template instances for the specified string templates. Cached templates will be considered + /// and if they do not exist, new types will be created and instantiated. + /// </summary> + /// <param name="razorTemplates">The set of templates to create.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="cacheNames">The set of cache names.</param> + /// <param name="parallel">Flag to determine whether to get the templates in parallel.</param> + /// <returns>The set of <see cref="ITemplate"/> instances.</returns> + public virtual IEnumerable<ITemplate> GetTemplates(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<string> cacheNames, bool parallel = false) + { + Contract.Requires(razorTemplates != null); + Contract.Requires(cacheNames != null); + Contract.Requires(razorTemplates.Count() == models.Count(), + "Expected same number of models as string templates to be processed."); + Contract.Requires(razorTemplates.Count() == cacheNames.Count(), + "Expected same number of cache names as string templates to be processed."); + + var modelList = (models == null) ? null : models.ToList(); + var cacheNameList = cacheNames.ToList(); + + if (parallel) + return GetParallelQueryPlan<string>() + .CreateQuery(razorTemplates) + .Select((t, i) => GetTemplate(t, + (modelList == null) ? null : modelList[i], + cacheNameList[i])); + + return razorTemplates.Select((t, i) => GetTemplate(t, + (modelList == null) ? null : modelList[i], + cacheNameList[i])); + } + + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + [Pure] + public virtual string Parse(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName) + { + ITemplate instance; + + if (cacheName == null) + instance = CreateTemplate(razorTemplate, null, model); + else + instance = GetTemplate(razorTemplate, model, cacheName); + + return Run(instance, viewBag); + } + + + /// <summary> + /// Parses and returns the result of the specified string template. + /// </summary> + /// <param name="razorTemplate">The string template.</param> + /// <param name="model">The model instance or NULL if no model exists.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param> + /// <returns>The string result of the template.</returns> + [Pure] + public virtual string Parse<T>(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName) + { + ITemplate instance; + + if (cacheName == null) + instance = CreateTemplate(razorTemplate, typeof(T), model); + else + instance = GetTemplate<T>(razorTemplate, model, cacheName); + + return Run(instance, viewBag); + } + + /// <summary> + /// Parses the specified set of templates. + /// </summary> + /// <param name="razorTemplates">The set of string templates to parse.</param> + /// <param name="models"> + /// The set of models or NULL if no models exist for all templates. + /// Individual elements in this set may be NULL if no model exists for a specific template. + /// </param> + /// <param name="viewBags"> + /// The set of initial ViewBag contents or NULL for an initially empty ViewBag for all templates. + /// Individual elements in this set may be NULL if an initially empty ViewBag is desired for a specific template. + /// </param> + /// <param name="cacheNames"> + /// The set of cache names or NULL if no caching is desired for all templates. + /// Individual elements in this set may be NULL if caching is not desired for specific template. + /// </param> + /// <param name="parallel">Flag to determine whether parsing in parallel.</param> + /// <returns>The set of parsed template results.</returns> + public virtual IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<DynamicViewBag> viewBags, IEnumerable<string> cacheNames, bool parallel) + { + if (razorTemplates == null) + throw new ArgumentException("Expected at least one entry in razorTemplates collection."); + + if ((models != null) && (razorTemplates.Count() != models.Count())) + throw new ArgumentException("Expected same number of models as string templates to be processed."); + + if ((viewBags != null) && (razorTemplates.Count() != viewBags.Count())) + throw new ArgumentException("Expected same number of viewBags as string templates to be processed."); + + if ((cacheNames != null) && (razorTemplates.Count() != cacheNames.Count())) + throw new ArgumentException("Expected same number of cacheNames as string templates to be processed."); + + var modelList = (models == null) ? null : models.ToList(); + var viewBagList = (viewBags == null) ? null : viewBags.ToList(); + var cacheNameList = (cacheNames == null) ? null : cacheNames.ToList(); + + // + // :Matt: + // What is up with the GetParallelQueryPlan() here? + // o Everywhere else in the code we simply return the ParallelQueryPlan + // (this implements IEnumerablt<T> + // o However, when I remove the ToArray() in the following code, + // the unit tests that call ParseMany() start failing, complaining + // about serialization (give it a try) + // o Should all GetParallelQueryPlan() results call ToList() + // to force Linq to execute the results? + // o If we do not call ToArray() below, then the Parse() + // method never gets called. + // o Something is wrong or inconsistent here. :) + // + if (parallel) + { + return GetParallelQueryPlan<string>() + .CreateQuery(razorTemplates) + .Select((t, i) => Parse(t, + (modelList == null) ? null : modelList[i], + (viewBagList == null) ? null : viewBagList[i], + (cacheNameList == null) ? null : cacheNameList[i])) + .ToArray(); + } + return razorTemplates.Select((t, i) => Parse(t, + (modelList == null) ? null : modelList[i], + (viewBagList == null) ? null : viewBagList[i], + (cacheNameList == null) ? null : cacheNameList[i])) + .ToArray(); + } + + /// <summary> + /// Returns whether or not a template by the specified name has been created already. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>Whether or not the template has been created.</returns> + public bool HasTemplate(string cacheName) + { + return _cache.ContainsKey(cacheName); + } + + /// <summary> + /// Remove a template by the specified name from the cache. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <returns>Whether or not the template has been removed.</returns> + public bool RemoveTemplate(string cacheName) + { + CachedTemplateItem item; + return _cache.TryRemove(cacheName, out item); + } + + + /// <summary> + /// Resolves the template with the specified name. + /// </summary> + /// <param name="cacheName">The name of the template type in cache.</param> + /// <param name="model">The model or NULL if there is no model for the template.</param> + /// <returns>The resolved template.</returns> + public virtual ITemplate Resolve(string cacheName, object model) + { + CachedTemplateItem cachedItem; + ITemplate instance = null; + if (_cache.TryGetValue(cacheName, out cachedItem)) + instance = CreateTemplate(null, cachedItem.TemplateType, model); + + if (instance == null && _config.Resolver != null) + { + string template = _config.Resolver.Resolve(cacheName); + if (!string.IsNullOrWhiteSpace(template)) + instance = GetTemplate(template, model, cacheName); + } + + return instance; + } + + /// <summary> + /// Runs the template with the specified cacheName. + /// </summary> + /// <param name="cacheName">The name of the template in cache. The template must be in cache.</param> + /// <param name="model">The model for the template or NULL if there is no model.</param> + /// <param name="viewBag">The initial ViewBag contents NULL for an empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + public string Run(string cacheName, object model, DynamicViewBag viewBag) + { + if (string.IsNullOrWhiteSpace(cacheName)) + throw new ArgumentException("'cacheName' is a required parameter."); + + CachedTemplateItem item; + if (!(_cache.TryGetValue(cacheName, out item))) + throw new InvalidOperationException("No template exists with name '" + cacheName + "'"); + + ITemplate instance = CreateTemplate(null, item.TemplateType, model); + + return Run(instance, viewBag); + } + + /// <summary> + /// Runs the specified template and returns the result. + /// </summary> + /// <param name="template">The template to run.</param> + /// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param> + /// <returns>The string result of the template.</returns> + public string Run(ITemplate template, DynamicViewBag viewBag) + { + if (template == null) + throw new ArgumentNullException("template"); + + return template.Run(CreateExecuteContext(viewBag)); + } + + /// <summary> + /// Sets the model for the template. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + /// <param name="template">The template instance.</param> + /// <param name="model">The model instance.</param> + private static void SetModel<T>(ITemplate template, T model) + { + if (model == null) return; + + var dynamicTemplate = template as ITemplate<dynamic>; + if (dynamicTemplate != null) + { + dynamicTemplate.Model = model; + return; + } + + var staticModel = template as ITemplate<T>; + if (staticModel != null) + { + staticModel.Model = model; + return; + } + + SetModelExplicit(template, model); + } + + /// <summary> + /// Sets the model for the template. + /// </summary> + /// <remarks> + /// This method uses reflection to set the model property. As we can't guaruntee that we know + /// what model type they will be using, we have to do the hard graft. The preference would be + /// to use the generic <see cref="SetModel{T}"/> method instead. + /// </remarks> + /// <param name="template">The template instance.</param> + /// <param name="model">The model instance.</param> + private static void SetModelExplicit(ITemplate template, object model) + { + var type = template.GetType(); + var prop = type.GetProperty("Model"); + + if (prop != null) + prop.SetValue(template, model, null); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TemplateServiceFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,39 @@ +namespace RazorEngine.Templating +{ + using Configuration; + + /// <summary> + /// Provides factory methods for creating <see cref="ITemplateService"/> instances. + /// </summary> + public static class TemplateServiceFactory + { + #region Fields + private static readonly RazorEngineConfigurationSection Configuration; + #endregion + + #region Constructor + /// <summary> + /// Initialises the <see cref="TemplateServiceFactory"/> type. + /// </summary> + static TemplateServiceFactory() + { + Configuration = RazorEngineConfigurationSection.GetConfiguration(); + } + #endregion + + #region Methods + + /// <summary> + /// Creates an instance of a template service. + /// </summary> + /// <param name="language">The language to use in this service.</param> + /// <param name="encoding">The type of encoding to use in this service.</param> + /// <returns></returns> + public static ITemplateService CreateTemplateService(Language language, Encoding encoding) + { + return null; + } + + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TemplateWriter.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,54 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Diagnostics.Contracts; + using System.Globalization; + using System.IO; + + /// <summary> + /// Defines a template writer used for helper templates. + /// </summary> + public class TemplateWriter + { + #region Fields + private readonly Action<TextWriter> writerDelegate; + #endregion + + #region Constructors + /// <summary> + /// Initialises a new instance of <see cref="TemplateWriter"/>. + /// </summary> + /// <param name="writer">The writer delegate used to write using the specified <see cref="TextWriter"/>.</param> + public TemplateWriter(Action<TextWriter> writer) + { + Contract.Requires(writer != null); + + writerDelegate = writer; + } + #endregion + + #region Methods + /// <summary> + /// Executes the write delegate and returns the result of this <see cref="TemplateWriter"/>. + /// </summary> + /// <returns>The string result of the helper template.</returns> + public override string ToString() + { + using (var writer = new StringWriter(CultureInfo.InvariantCulture)) + { + writerDelegate(writer); + return writer.ToString(); + } + } + + /// <summary> + /// Writes the helper result of the specified text writer. + /// </summary> + /// <param name="writer">The text writer to write the helper result to.</param> + public void WriteTo(TextWriter writer) + { + writerDelegate(writer); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Templating/TypeLoader.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,121 @@ +namespace RazorEngine.Templating +{ + using System; + using System.Collections.Concurrent; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + using System.Linq; + using System.Linq.Expressions; + using System.Reflection; + + /// <summary> + /// Defines a type loader. + /// </summary> + public class TypeLoader : IDisposable + { + #region Fields + private readonly AppDomain _appDomain; + private readonly IEnumerable<Assembly> _assemblies; + private readonly ConcurrentDictionary<Type, Func<ITemplate>> _constructors; + private readonly ResolveEventHandler _resolveEventHandler; + private bool disposed; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="TypeLoader"/> + /// </summary> + /// <param name="appDomain">The application domain.</param> + /// <param name="assemblies">The set of assemblies.</param> + public TypeLoader(AppDomain appDomain, IEnumerable<Assembly> assemblies) + { + Contract.Requires(appDomain != null); + Contract.Requires(assemblies != null); + + _appDomain = appDomain; + _assemblies = assemblies; + _constructors = new ConcurrentDictionary<Type, Func<ITemplate>>(); + _resolveEventHandler = (s, e) => ResolveAssembly(e.Name); + + _appDomain.AssemblyResolve += _resolveEventHandler; + } + #endregion + + #region Methods + /// <summary> + /// Creates an instance of the specified type. + /// </summary> + /// <param name="type">The type to create.</param> + /// <returns>An instance of the type.</returns> + public ITemplate CreateInstance(Type type) + { + Contract.Requires(type != null); + + if (disposed) + throw new ObjectDisposedException("TypeLoader"); + + var ctor = GetConstructor(type); + return ctor(); + } + + /// <summary> + /// Releases resources used by this instance. + /// </summary> + /// <param name="disposing">Flag to determine whether this instance is being disposed of explicitly.</param> + protected virtual void Dispose(bool disposing) + { + if (!disposed && disposing) + { + _appDomain.AssemblyResolve -= _resolveEventHandler; + disposed = true; + } + } + + /// <summary> + /// Releases resources used by this reference. + /// </summary> + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// <summary> + /// Gets the delegate used to create an instance of the template type. + /// This method will consider the cached constructor delegate before creating an instance of one. + /// </summary> + /// <param name="type">The template type.</param> + /// <returns>The delegate instance.</returns> + private Func<ITemplate> GetConstructor(Type type) + { + return _constructors + .GetOrAdd(type, GetConstructorInternal); + } + + /// <summary> + /// Gets the delegate used to create an instance of the template type. + /// </summary> + /// <param name="type">The template type.</param> + /// <returns>The delegate instance.</returns> + private static Func<ITemplate> GetConstructorInternal(Type type) + { + var method = type.GetConstructor(new Type[0]); + + return Expression.Lambda<Func<ITemplate>>( + Expression.New(method)).Compile(); + } + + /// <summary> + /// Resolves the assembly with the specified name. + /// </summary> + /// <param name="name">The name of the assembly.</param> + /// <returns>The assembly instance, or null.</returns> + private Assembly ResolveAssembly(string name) + { + return _assemblies + .Where(a => a.FullName.Equals(name)) + .FirstOrDefault(); + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Text/HtmlEncodedString.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,46 @@ +namespace RazorEngine.Text +{ + using System.Net; + + /// <summary> + /// Represents a Html-encoded string. + /// </summary> + public class HtmlEncodedString : IEncodedString + { + #region Fields + private readonly string _encodedString; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="HtmlEncodedString"/> + /// </summary> + /// <param name="value">The raw string to be encoded.</param> + public HtmlEncodedString(string value) + { + if (!string.IsNullOrWhiteSpace(value)) + _encodedString = WebUtility.HtmlEncode(value); + } + #endregion + + #region Methods + /// <summary> + /// Gets the encoded string. + /// </summary> + /// <returns>The encoded string.</returns> + public string ToEncodedString() + { + return _encodedString ?? string.Empty; + } + + /// <summary> + /// Gets the string representation of this instance. + /// </summary> + /// <returns>The string representation of this instance.</returns> + public override string ToString() + { + return ToEncodedString(); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Text/HtmlEncodedStringFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,37 @@ +namespace RazorEngine.Text +{ + /// <summary> + /// Represents a factory that creates <see cref="HtmlEncodedString"/> instances. + /// </summary> + public class HtmlEncodedStringFactory : IEncodedStringFactory + { + #region Methods + /// <summary> + /// Creates a <see cref="IEncodedString"/> instance for the specified raw string. + /// </summary> + /// <param name="rawString">The raw string.</param> + /// <returns>An instance of <see cref="IEncodedString"/>.</returns> + public IEncodedString CreateEncodedString(string rawString) + { + return new HtmlEncodedString(rawString); + } + + /// <summary> + /// Creates a <see cref="IEncodedString"/> instance for the specified object instance. + /// </summary> + /// <param name="value">The object instance.</param> + /// <returns>An instance of <see cref="IEncodedString"/>.</returns> + public IEncodedString CreateEncodedString(object value) + { + if (value == null) + return new HtmlEncodedString(string.Empty); + + var htmlString = value as HtmlEncodedString; + if (htmlString != null) + return htmlString; + + return new HtmlEncodedString(value.ToString()); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Text/IEncodedString.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,16 @@ +namespace RazorEngine.Text +{ + /// <summary> + /// Defines the required contract for implementing an encoded string. + /// </summary> + public interface IEncodedString + { + #region Methods + /// <summary> + /// Gets the encoded string. + /// </summary> + /// <returns>The encoded string.</returns> + string ToEncodedString(); + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Text/IEncodedStringFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,24 @@ +namespace RazorEngine.Text +{ + /// <summary> + /// Defines the required contract for implementing a factory for building encoded strings. + /// </summary> + public interface IEncodedStringFactory + { + #region Methods + /// <summary> + /// Creates a <see cref="IEncodedString"/> instance for the specified raw string. + /// </summary> + /// <param name="value">The raw string.</param> + /// <returns>An instance of <see cref="IEncodedString"/>.</returns> + IEncodedString CreateEncodedString(string value); + + /// <summary> + /// Creates a <see cref="IEncodedString"/> instance for the specified object instance. + /// </summary> + /// <param name="value">The object instance.</param> + /// <returns>An instance of <see cref="IEncodedString"/>.</returns> + IEncodedString CreateEncodedString(object value); + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Text/RawString.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,43 @@ +namespace RazorEngine.Text +{ + /// <summary> + /// Represents an unencoded string. + /// </summary> + public class RawString : IEncodedString + { + #region Fields + private readonly string _value; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="RawString"/> + /// </summary> + /// <param name="value">The value</param> + public RawString(string value) + { + _value = value; + } + #endregion + + #region Methods + /// <summary> + /// Gets the encoded string. + /// </summary> + /// <returns>The encoded string.</returns> + public string ToEncodedString() + { + return _value ?? string.Empty; + } + + /// <summary> + /// Gets the string representation of this instance. + /// </summary> + /// <returns>The string representation of this instance.</returns> + public override string ToString() + { + return ToEncodedString(); + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/Text/RawStringFactory.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,32 @@ +namespace RazorEngine.Text +{ + /// <summary> + /// Represents a factory that creates <see cref="RawString"/> instances. + /// </summary> + public class RawStringFactory : IEncodedStringFactory + { + #region Methods + /// <summary> + /// Creates a <see cref="IEncodedString"/> instance for the specified raw string. + /// </summary> + /// <param name="value">Thevalue.</param> + /// <returns>An instance of <see cref="IEncodedString"/>.</returns> + public IEncodedString CreateEncodedString(string value) + { + return new RawString(value); + } + + /// <summary> + /// Creates a <see cref="IEncodedString"/> instance for the specified object instance. + /// </summary> + /// <param name="value">The value.</param> + /// <returns>An instance of <see cref="IEncodedString"/>.</returns> + public IEncodedString CreateEncodedString(object value) + { + return (value == null) + ? new RawString(string.Empty) + : new RawString(value.ToString()); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/RazorEngine.Core/packages.config Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="utf-8"?> +<packages> + <package id="Microsoft.AspNet.Razor" version="3.0.0" targetFramework="net45" /> +</packages> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/ActivatorTestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,53 @@ +namespace RazorEngine.Tests +{ + using System; + using System.IO; + + using Microsoft.Practices.Unity; + using Moq; + using NUnit.Framework; + + using Compilation; + using Configuration; + using Templating; + using TestTypes; + using TestTypes.Activation; + using Text; + + /// <summary> + /// Defines a test fixture that provides tests for the <see cref="IActivator"/> type. + /// </summary> + [TestFixture] + public class ActivatorTestFixture + { + #region Tests + /// <summary> + /// Tests that a custom activator can be used. In this test case, we're using Unity + /// to handle a instantiation of a custom activator. + /// </summary> + [Test] + public void TemplateService_CanSupportCustomActivator_WithUnity() + { + var container = new UnityContainer(); + container.RegisterType(typeof(ITextFormatter), typeof(ReverseTextFormatter)); + + var config = new TemplateServiceConfiguration + { + Activator = new UnityTemplateActivator(container), + BaseTemplateType = typeof(CustomTemplateBase<>) + }; + + using (var service = new TemplateService(config)) + { + const string template = "<h1>Hello @Format(Model.Forename)</h1>"; + const string expected = "<h1>Hello ttaM</h1>"; + + var model = new Person { Forename = "Matt" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/CodeInspectorTestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,37 @@ +namespace RazorEngine.Tests +{ + using System; + + using NUnit.Framework; + + using Compilation.Inspectors; + using Configuration; + using Templating; + using TestTypes.Inspectors; + + /// <summary> + /// Defines a test fixture that provides tests for the <see cref="ICodeInspector"/> type. + /// </summary> + [TestFixture] + public class CodeInspectorTestFixture + { + #region Tests + /// <summary> + /// Tests that a code inspector supports add a custom inspector. + /// </summary> + [Test] + public void CodeInspector_SupportsAddingCustomInspector() + { + var config = new TemplateServiceConfiguration(); + config.CodeInspectors.Add(new ThrowExceptionCodeInspector()); + + using (var service = new TemplateService(config)) + { + const string template = "Hello World"; + + Assert.Throws<InvalidOperationException>(() => service.Parse(template, null, null, null)); + } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/ConfigurationTestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,192 @@ +namespace RazorEngine.Tests +{ + using System; + using System.IO; + + using Moq; + using NUnit.Framework; + + using Compilation; + using Configuration; + using Templating; + using Text; + + /// <summary> + /// Defines a test fixture that provides tests for the <see cref="ITemplateServiceConfiguration"/> type. + /// </summary> + [TestFixture] + public class ConfigurationTestFixture + { + #region Tests + /// <summary> + /// Tests that the fluent configuration supports adding additional namespace imports. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanAddNamespaces() + { + var config = new FluentTemplateServiceConfiguration(c => c.IncludeNamespaces("RazorEngine.Templating")); + + Assert.That(config.Namespaces.Contains("RazorEngine.Templating")); + } + + /// <summary> + /// Tests that the fluent configuration can configure a template service with additional namespaces. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanConfigureTemplateService_WithAdditionalNamespaces() + { + var config = new FluentTemplateServiceConfiguration( + c => c.IncludeNamespaces("System.IO")); + + using (var service = new TemplateService(config)) + { + const string template = "@Directory.GetFiles(\"C:\\\\\", \"*.*\").Length"; + + int expected = Directory.GetFiles(@"C:\", "*.*").Length; + string result = service.Parse(template, null, null, null); + + Assert.That(expected == int.Parse(result)); + } + } + + /// <summary> + /// Tests that the fluent configuration can configure a template service with a specific code language. + /// </summary> + /// <remarks> + /// For this test, we're switching to VB, and using a @Code section: + /// <code> + /// @Code Dim name = "Matt" End Code + /// @name + /// </code> + /// ... which should result in: + /// <code> + /// + /// Matt + /// </code> + /// </remarks> + [Test] + public void FluentTemplateServiceConfiguration_CanConfigureTemplateService_WithSpecificCodeLanguage() + { + var config = new FluentTemplateServiceConfiguration( + c => c.WithCodeLanguage(Language.VisualBasic)); + + using (var service = new TemplateService(config)) + { + const string template = "@Code Dim name = \"Matt\" End Code\n@name"; + const string expected = "\nMatt"; + + string result = service.Parse(template, null, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that the fluent configuration can configure a template service with a specific encoding. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanConfigureTemplateService_WithSpecificEncoding() + { + var config = new FluentTemplateServiceConfiguration( + c => c.WithEncoding(Encoding.Raw)); + + using (var service = new TemplateService(config)) + { + const string template = "<h1>Hello @Model.String</h1>"; + const string expected = "<h1>Hello Matt & World</h1>"; + + var model = new { String = "Matt & World" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that the fluent configuration supports setting a custom activator. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanSetActivator_UsingActivator() + { + var mock = new Mock<IActivator>(); + + var config = new FluentTemplateServiceConfiguration(c => c.ActivateUsing(mock.Object)); + + Assert.That(config.Activator == mock.Object); + } + + /// <summary> + /// Tests that the fluent configuration supports setting the code language. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanSetCodeLanguage() + { + var config = new FluentTemplateServiceConfiguration(c => c.WithCodeLanguage(Language.VisualBasic)); + + Assert.That(config.Language == Language.VisualBasic); + } + + /// <summary> + /// Tests that the fluent configuration supports setting the compiler service factory. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanSetCompilerServiceFactory() + { + var mock = new Mock<ICompilerServiceFactory>(); + + var config = new FluentTemplateServiceConfiguration(c => c.CompileUsing(mock.Object)); + + Assert.That(config.CompilerServiceFactory == mock.Object); + } + + /// <summary> + /// Tests that the fluent configuration supports setting the encoded string factory. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanSetEncodedStringFactory() + { + var mock = new Mock<IEncodedStringFactory>(); + + var config = new FluentTemplateServiceConfiguration(c => c.EncodeUsing(mock.Object)); + + Assert.That(config.EncodedStringFactory == mock.Object); + } + + /// <summary> + /// Tests that the fluent configuration supports setting the encoded string factory using a predefined encoding. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanSetEncoding_UsingHtmlEncoding() + { + var config = new FluentTemplateServiceConfiguration(c => c.WithEncoding(Encoding.Html)); + + Assert.That(config.EncodedStringFactory is HtmlEncodedStringFactory); + } + + /// <summary> + /// Tests that the fluent configuration supports setting the encoded string factory using a predefined encoding. + /// </summary> + [Test] + public void FluentTemplateServiceConfiguration_CanSetEncoding_UsingRawEncoding() + { + var config = new FluentTemplateServiceConfiguration(c => c.WithEncoding(Encoding.Raw)); + + Assert.That(config.EncodedStringFactory is RawStringFactory); + } + + /// <summary> + /// Tests that the fluent configuration supports setting a custom activator delegate. + /// </summary> + [Test] + public void FluentTemplateServiceConfigutation_CanSetActivator_UsingDelegate() + { + Func<InstanceContext, ITemplate> activator = i => null; + + var config = new FluentTemplateServiceConfiguration(c => c.ActivateUsing(activator)); + var delegateActivator = (DelegateActivator)config.Activator; + + Assert.That(delegateActivator.Activator == activator); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/IsolatedTemplateServiceTestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,308 @@ +namespace RazorEngine.Tests +{ + using System; + using System.Collections.Generic; + using System.Dynamic; + using System.Linq; + using System.Runtime.Serialization; + + using NUnit.Framework; + + using Compilation; + using Templating; + using TestTypes; + + /// <summary> + /// Defines a test fixture that provides tests for the <see cref="IsolatedTemplateService"/> type. + /// </summary> + [TestFixture] + public class IsolatedTemplateServiceTestFixture + { + #region Tests + /// <summary> + /// Tests that a simple template without a model can be parsed. + /// </summary> + [Test] + public void IsolatedTemplateService_CanParseSimpleTemplate_WithNoModel() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Hello World</h1>"; + const string expected = template; + + string result = service.Parse(template, null, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with a model can be parsed. + /// </summary> + [Test] + public void IsolatedTemplateService_CanParseSimpleTemplate_WithComplexSerializableModel() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + const string expected = "<h1>Hello Matt</h1>"; + + var model = new Person { Forename = "Matt" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with a non-serializable model cannot be parsed. + /// </summary> + [Test] + public void IsolatedTemplateService_CannotParseSimpleTemplate_WithComplexNonSerializableModel() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Animal Type: @Model.Type</h1>"; + + Assert.Throws<SerializationException>(() => + { + var model = new Animal { Type = "Cat" }; + service.Parse(template, model, null, null); + }); + } + } + + /// <summary> + /// Tests that a simple template with an anonymous model cannot be parsed. + /// </summary> + /// <remarks> + /// This may seem pointless to test, as the <see cref="IsolatedTemplateService"/> will explicitly + /// check and throw the exception, it's worth creating a test for future reference. It's also + /// something we can check should we ever find a way to support dynamic/anonymous objects + /// across application domain boundaries. + /// </remarks> + [Test] + public void IsolatedTemplateService_CannotParseSimpleTemplate_WithAnonymousModel() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Animal Type: @Model.Type</h1>"; + + Assert.Throws<ArgumentException>(() => + { + var model = new { Type = "Cat" }; + service.Parse(template, model, null, null); + }); + } + } + + /// <summary> + /// Tests that a simple template with an expando model cannot be parsed. + /// </summary> + /// <remarks> + /// This may seem pointless to test, as the <see cref="IsolatedTemplateService"/> will explicitly + /// check and throw the exception, it's worth creating a test for future reference. It's also + /// something we can check should we ever find a way to support dynamic/anonymous objects + /// across application domain boundaries. + /// </remarks> + [Test] + public void IsolatedTemplateService_CannotParseSimpleTemplate_WithExpandoModel() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Animal Type: @Model.Type</h1>"; + + Assert.Throws<ArgumentException>(() => + { + dynamic model = new ExpandoObject(); + model.Type = "Cat"; + service.Parse(template, model, null, null); + }); + } + } + + /// <summary> + /// Tests that a simple template with a dynamic model cannot be parsed. + /// </summary> + /// <remarks> + /// This may seem pointless to test, as the <see cref="IsolatedTemplateService"/> will explicitly + /// check and throw the exception, it's worth creating a test for future reference. It's also + /// something we can check should we ever find a way to support dynamic/anonymous objects + /// across application domain boundaries. + /// </remarks> + [Test] + public void IsolatedTemplateService_CannotParseSimpleTemplate_WithDynamicModel() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Animal Type: @Model.Type</h1>"; + + Assert.Throws<ArgumentException>(() => + { + dynamic model = new ValueObject(new Dictionary<string, object> { { "Type", "Cat" } }); + service.Parse(template, model, null, null); + }); + } + } + + /// <summary> + /// Tests that an isolated template service cannot use the same application domain as the + /// main application domain. + /// </summary> + /// <remarks> + /// An isolated template service will unload it's child application domain on Dispose. We need to ensure + /// it doesn't attempt to unload the current application domain that it is running in. This may or may + /// not be the main application domain (but is very likely to be). + /// </remarks> + [Test] + public void IsolatedTemplateService_WillThrowException_WhenUsingMainAppDomain() + { + Assert.Throws<InvalidOperationException>(() => + { + using (var service = new IsolatedTemplateService(() => AppDomain.CurrentDomain)) + { } + }); + } + + /// <summary> + /// Tests that an isolated template service cannot use a null application domain. + /// </summary> + /// <remarks> + /// I had considered using the default <see cref="IAppDomainFactory"/> to spawn a default + /// application domain to load templates into when a null value is returned, but behaviourly this didn't + /// seem like the right thing to do. If you're using an <see cref="IsolatedTemplateService"/>, + /// you should expect it to have a valid application domain, so passing null should cause an exception. + /// </remarks> + [Test] + public void IsolatedTemplateService_WillThrowException_WhenUsingNullAppDomain() + { + Assert.Throws<InvalidOperationException>(() => + { + using (var service = new IsolatedTemplateService(() => null)) + { } + }); + } + + /// <summary> + /// Tests that a simple template with html-encoding can be parsed. + /// </summary> + /// <remarks> + /// Text encoding is performed when writing objects to the template result (not literals). This test should + /// show that the template service is correctly providing the appropriate encoding factory to process + /// the object's .ToString() and automatically encode it. + /// </remarks> + [Test] + public void IsolatedTemplateService_CanParseSimpleTemplate_UsingHtmlEncoding() + { + + using (var service = new IsolatedTemplateService(Encoding.Html)) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + const string expected = "<h1>Hello Matt & World</h1>"; + + var model = new Person { Forename = "Matt & World" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with no-encoding can be parsed. + /// </summary> + /// <remarks> + /// Text encoding is performed when writing objects to the template result (not literals). This test should + /// show that the template service is correctly providing the appropriate encoding factory to process + /// the object's .ToString() and automatically encode it. + /// </remarks> + [Test] + public void IsolatedTemplateService_CanParseSimpleTemplate_UsingRawEncoding() + { + using (var service = new IsolatedTemplateService(Encoding.Raw)) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + const string expected = "<h1>Hello Matt & World</h1>"; + + var model = new Person { Forename = "Matt & World" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in sequence. + /// </summary> + [Test] + public void IsolatedTemplateService_CanParseMultipleTemplatesInSequence_WitNoModels() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Hello World</h1>"; + var templates = Enumerable.Repeat(template, 10).ToArray(); + + var results = service.ParseMany(templates, null, null, null, false); + + Assert.That(templates.SequenceEqual(results), "Rendered templates do not match expected."); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in parallel. + /// </summary> + [Test] + public void IsolatedTemplateService_CanParseMultipleTemplatesInParallel_WitNoModels() + { + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Hello World</h1>"; + var templates = Enumerable.Repeat(template, 10).ToArray(); + + var results = service.ParseMany(templates, null, null, null, true); + + Assert.That(templates.SequenceEqual(results), "Rendered templates do not match expected."); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in sequence with complex models. + /// </summary> + [Test] + public void IsolatedTemplateService_CanParseMultipleTemplatesInSequence_WithComplexModels() + { + const int maxTemplates = 10; + + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Age: @Model.Age</h1>"; + var expected = Enumerable.Range(1, maxTemplates).Select(i => string.Format("<h1>Age: {0}</h1>", i)); + var templates = Enumerable.Repeat(template, maxTemplates).ToArray(); + var models = Enumerable.Range(1, maxTemplates).Select(i => new Person { Age = i }).ToArray(); + + var results = service.ParseMany(templates, models, null, null, false); + Assert.That(expected.SequenceEqual(results), "Parsed templates do not match expected results."); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in parallel with complex models. + /// </summary> + [Test] + public void IsolatedTemplateService_CanParseMultipleTemplatesInParallel_WithComplexModels() + { + const int maxTemplates = 10; + + using (var service = new IsolatedTemplateService()) + { + const string template = "<h1>Age: @Model.Age</h1>"; + var expected = Enumerable.Range(1, maxTemplates).Select(i => string.Format("<h1>Age: {0}</h1>", i)); + var templates = Enumerable.Repeat(template, maxTemplates).ToArray(); + var models = Enumerable.Range(1, maxTemplates).Select(i => new Person { Age = i }).ToArray(); + + var results = service.ParseMany(templates, models, null, null, true); + Assert.That(expected.SequenceEqual(results), "Parsed templates do not match expected results."); + } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/Issues/Release_3_0_TestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,382 @@ +namespace RazorEngine.Tests.TestTypes.Issues +{ + using System; + using System.Collections.Generic; + using Microsoft.CSharp.RuntimeBinder; + + using NUnit.Framework; + + using Configuration; + using Templating; + + /// <summary> + /// Provides tests for the Release 3.0 + /// </summary> + [TestFixture] + public class Release_3_0_TestFixture + { + #region Tests + /// <summary> + /// When using a template layout, the model needs to be passed to the layout template from the child. + /// + /// Issue 6: https://github.com/Antaris/RazorEngine/issues/6 + /// </summary> + [Test] + public void Issue6_ModelShouldBePassedToLayout() + { + using (var service = new TemplateService()) + { + const string layoutTemplate = "<h1>@Model.PageTitle</h1> @RenderSection(\"Child\")"; + const string childTemplate = "@{ Layout = \"Parent\"; }@section Child {<h2>@Model.PageDescription</h2>}"; + const string expected = "<h1>Test Page</h1> <h2>Test Page Description</h2>"; + + var model = new { + PageTitle = "Test Page", + PageDescription = "Test Page Description" + }; + + var type = model.GetType(); + + service.Compile(layoutTemplate, type, "Parent"); + + string result = service.Parse(childTemplate, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// A viewbag property is an easy way to share state between layout templates and the rendering template. The ViewBag property + /// needs to persist from layouts and child templates. + /// + /// Issue 7: https://github.com/Antaris/RazorEngine/issues/7 + /// </summary> + [Test] + public void Issue7_ViewBagShouldPersistThroughLayout() + { + using (var service = new TemplateService()) + { + const string layoutTemplate = "<h1>@ViewBag.Title</h1>@RenderSection(\"Child\")"; + const string childTemplate = "@{ Layout = \"Parent\"; ViewBag.Title = \"Test\"; }@section Child {}"; + + service.Compile(layoutTemplate, null, "Parent"); + + string result = service.Parse(childTemplate, null, null, null); + + Assert.That(result.StartsWith("<h1>Test</h1>")); + } + } + + /// <summary> + /// A viewbag property should not persist through using @Include as this will create a new <see cref="ExecuteContext" />, which + /// initialises a new viewbag property. + /// + /// Issue 7: https://github.com/Antaris/RazorEngine/issues/7 + /// </summary> + /// <remarks> + /// This test no longer pass as we have changed the ViewBag property to be a fault tollerant dynamic dictionary. + /// </remarks> + [Test] + public void Issue7_ViewBagShouldNotPersistThroughInclude_UsingCSharp() + { +// using (var service = new TemplateService()) +// { +// const string parentTemplate = "@{ ViewBag.Title = \"Test\"; }@Include(\"Child\")"; +// const string childTemplate = "@ViewBag.Title"; +// +// service.Compile(childTemplate, "Child"); +// +// // The C# runtime binder will throw a RuntimeBinderException... +// Assert.Throws<RuntimeBinderException>(() => +// { +// string result = service.Parse(parentTemplate); +// }); +// } + } + + /// <summary> + /// A viewbag property should not persist through using @Include as this will create a new <see cref="ExecuteContext" />, which + /// initialises a new viewbag property. + /// + /// Issue 7: https://github.com/Antaris/RazorEngine/issues/7 + /// </summary> + /// <remarks> + /// This test no longer pass as we have changed the ViewBag property to be a fault tollerant dynamic dictionary. + /// </remarks> + [Test] + public void Issue7_ViewBagShouldNotPersistThroughInclude_UsingVB() + { +// var config = new TemplateServiceConfiguration() { Language = Language.VisualBasic }; +// using (var service = new TemplateService(config)) +// { +// const string parentTemplate = @" +//@Code +// ViewBag.Title = ""Test"" +//End Code +//@Include(""Child"")"; +// const string childTemplate = "@ViewBag.Title"; +// +// service.Compile(childTemplate, "Child"); +// +// // The VB runtime binder will through a MissingMemberException... +// Assert.Throws<MissingMemberException>(() => +// { +// string result = service.Parse(parentTemplate); +// }); +// } + } + + /// <summary> + /// The template service should have the ability to compile a template with out a model. + /// + /// Issue 11: https://github.com/Antaris/RazorEngine/issues/11 + /// </summary> + [Test] + public void Issue11_TemplateServiceShouldCompileModellessTemplate() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello World</h1>"; + + service.Compile(template, null, "issue11"); + } + } + + /// <summary> + /// The last property/method result in an expression, which returns a null value + /// should not write to the template. + /// + /// Issue 16: https://github.com/Antaris/RazorEngine/issues/16 + /// </summary> + [Test] + public void Issue16_LastNullValueShouldReturnEmptyString() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.Person.Forename</h1>"; + const string expected = "<h1>Hello </h1>"; + + var model = new { Person = new Person { Forename = null } }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// We should support overriding the model type for templates that do not specify @model. + /// + /// Issue 17: https://github.com/Antaris/RazorEngine/issues/17 + /// </summary> + [Test] + public void TemplateService_ShouldAllowTypeOverrideForNonGenericCompile() + { + using (var service = new TemplateService()) + { + const string template = "@Model.Name"; + const string expected = "Matt"; + + object model = new { Name = "Matt" }; + + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// We should support nullable value types in expressions. I think this will work because of the + /// change made for Issue 16. + /// + /// Issue 18: https://github.com/Antaris/RazorEngine/issues/18 + /// </summary> + [Test] + public void TemplateService_ShouldEnableNullableValueTypes() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.Number</h1>"; + const string expected = "<h1>Hello </h1>"; + + var model = new { Number = (int?)null }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Subclassed models should be supported in layouts (and also partials). + /// + /// Issue 21: https://github.com/Antaris/RazorEngine/issues/21 + /// </summary> + [Test] + public void Issue21_SubclassModelShouldBeSupportedInLayout() + { + using (var service = new TemplateService()) + { + const string parent = "@model RazorEngine.Tests.TestTypes.Person\n<h1>@Model.Forename</h1>@RenderSection(\"Child\")"; + service.Compile(parent, null, "Parent"); + + const string child = "@{ Layout = \"Parent\"; }\n@section Child { <h2>@Model.Department</h2> }"; + const string expected = "<h1>Matt</h1> <h2>IT</h2> "; + + var model = new Employee + { + Age = 27, + Department = "IT", + Forename = "Matt", + Surname = "Abbott" + }; + + string result = service.Parse(child, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Requested functionality to allow deep nulls on dynamic models to fail silently without throwing exceptions. + /// + /// Issue 22: https://github.com/Antaris/RazorEngine/issues/22 + /// </summary> + [Test] + public void Issue22_MissingDynamicPropertiesCausesException() + { + using (var service = new TemplateService(new TemplateServiceConfiguration() + { + AllowMissingPropertiesOnDynamic = true + })) + { + const string template = "Missing property: @Model.Something.SomethingElse"; + const string expected = "Missing property: "; + + var model = new { Name = "Matt" }; + + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// ViewBag initialization not possible outside of template. + /// + /// Issue 26: https://github.com/Antaris/RazorEngine/issues/26 + /// </summary> + [Test] + public void Issue26_ViewBagInitializationOutsideOfTemplate() + { + using (var service = new TemplateService()) + { + const string template = "@ViewBag.TestValue"; + const string expected = "This is a test"; + + DynamicViewBag viewBag = new DynamicViewBag(); + viewBag.AddValue("TestValue", "This is a test"); + + string result = service.Parse(template, null, viewBag, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// StreamLining the ITemplateServiceAPI. + /// + /// Issue 27: https://github.com/Antaris/RazorEngine/issues/27 + /// </summary> + /// <remarks> + /// Streamlining the interface did not change funcionality - it just consolidated + /// overloads into a single methods to simplify Interface implementation. + /// <br/><br/> + /// There is one exception - the CreateTemplates() method. + /// This was enhanced to:<br/> + /// 1) Allow a NULL razorTemplates parameter if templateTypes are specified.<br/> + /// 2) Allow a NULL templateTypes parameter if razorTemplates are specified.<br/> + /// 3) Allow both razorTemplates / templateTypes to be specified and have some templates and some templates dynamically compiled. + /// <br/><br/> + /// This test case tests for success and exception conditions in features 1-3. + /// </remarks> + [Test] + public void Issue27_StreamLiningTheITemplateServiceApi_CreateTemplates() + { + string[] razorTemplates; + Type[] templateTypes; + int index; + + using (var service = new TemplateService()) + { + // Success case + razorTemplates = new string[] { "Template1", "Template2", "Template3" }; + templateTypes = new Type[] { null, null, null }; + IEnumerable<ITemplate> instances = service.CreateTemplates(razorTemplates, templateTypes, null, false); + + index = 0; + foreach (ITemplate instance in instances) + { + string expected = razorTemplates[index]; + string result = service.Run(instance, null); + Assert.That(result == expected, "Result does not match expected: " + result); + index++; + } + + // No razorTemplates or templateTypes provided + Assert.Throws<ArgumentException>(() => + { + service.CreateTemplates(null, null, null, false); + }); + + // Unbalanced razorTemplates/templateTypes (templateTypes to small) + Assert.Throws<ArgumentException>(() => + { + razorTemplates = new string[] { "Template1", "Template2", "Template3" }; + templateTypes = new Type[] { null, null }; + service.CreateTemplates(razorTemplates, templateTypes, null, false); + }); + + // Unbalanced razorTemplates/templateTypes (templateTypes too large) + Assert.Throws<ArgumentException>(() => + { + razorTemplates = new string[] { "Template1", "Template2", "Template3" }; + templateTypes = new Type[] { null, null, null, null }; + service.CreateTemplates(razorTemplates, templateTypes, null, false); + }); + + // Unbalanced razorTemplates/templateTypes (razorTemplates and templateTypes are NULL) + Assert.Throws<ArgumentException>(() => + { + razorTemplates = new string[] { "Template1", "Template2", null }; + templateTypes = new Type[] { null, null, null }; + service.CreateTemplates(razorTemplates, templateTypes, null, false); + }); + } + } + + /// <summary> + /// Dynamic ViewBag properties should be persisted to the viewbag used for include templates. + /// + /// Issue 133: https://github.com/Antaris/RazorEngine/issues/133 + /// </summary> + [Test] + public void Issue133_ViewBagShouldPersistToIncludes() + { + using (var service = new TemplateService()) + { + const string child = "<h1>@ViewBag.Name</h1>"; + const string template = "@Include(\"Child\")"; + const string expected = "<h1>Matt</h1>"; + + dynamic bag = new DynamicViewBag(); + bag.Name = "Matt"; + + + service.GetTemplate(child, null, "Child"); + string result = service.Parse(template, null, bag, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/Properties/AssemblyInfo.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("RazorEngine.Core.Tests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Microsoft")] +[assembly: AssemblyProduct("RazorEngine.Core.Tests")] +[assembly: AssemblyCopyright("Copyright © Microsoft 2011")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("279faf7a-64a4-4537-b4cd-2023f6652acf")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")]
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/RazorEngine.Core.Tests.csproj Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,106 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>8.0.30703</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>RazorEngine.Tests</RootNamespace> + <AssemblyName>RazorEngine.Core.Tests</AssemblyName> + <TargetFrameworkVersion>v4.5</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <TargetFrameworkProfile /> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>TRACE;DEBUG</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + <Prefer32Bit>false</Prefer32Bit> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + <Prefer32Bit>false</Prefer32Bit> + </PropertyGroup> + <PropertyGroup> + <SignAssembly>true</SignAssembly> + </PropertyGroup> + <PropertyGroup> + <AssemblyOriginatorKeyFile>RazorEngine.snk</AssemblyOriginatorKeyFile> + </PropertyGroup> + <ItemGroup> + <Reference Include="Microsoft.Practices.Unity, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\..\packages\Unity.3.0.1304.1\lib\Net45\Microsoft.Practices.Unity.dll</HintPath> + </Reference> + <Reference Include="Microsoft.Practices.Unity.Configuration, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\..\packages\Unity.3.0.1304.1\lib\Net45\Microsoft.Practices.Unity.Configuration.dll</HintPath> + </Reference> + <Reference Include="Moq, Version=4.1.1309.1617, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\..\packages\Moq.4.1.1309.1617\lib\net40\Moq.dll</HintPath> + </Reference> + <Reference Include="nunit.framework, Version=2.6.3.13283, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath> + </Reference> + <Reference Include="System" /> + <Reference Include="System.Core" /> + <Reference Include="System.Web" /> + <Reference Include="Microsoft.CSharp" /> + </ItemGroup> + <ItemGroup> + <Compile Include="ActivatorTestFixture.cs" /> + <Compile Include="CodeInspectorTestFixture.cs" /> + <Compile Include="ConfigurationTestFixture.cs" /> + <Compile Include="IsolatedTemplateServiceTestFixture.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="RazorEngineHostTestFixture.cs" /> + <Compile Include="TemplateBaseTestFixture.cs" /> + <Compile Include="TemplateServiceTestFixture.cs" /> + <Compile Include="TestTypes\Activation\ITextFormatter.cs" /> + <Compile Include="TestTypes\Activation\ReverseTextFormatter.cs" /> + <Compile Include="TestTypes\Activation\UnityTemplateActivator.cs" /> + <Compile Include="TestTypes\Animal.cs" /> + <Compile Include="TestTypes\Activation\CustomTemplateBase.cs" /> + <Compile Include="TestTypes\AnimalViewModel.cs" /> + <Compile Include="TestTypes\BaseTypes\NonGenericTemplateBase.cs" /> + <Compile Include="TestTypes\Employee.cs" /> + <Compile Include="TestTypes\Inspectors\ThrowExceptionCodeInspector.cs" /> + <Compile Include="Issues\Release_3_0_TestFixture.cs" /> + <Compile Include="TestTypes\ThreadPoolItem.cs" /> + <Compile Include="TestTypes\ValueObject.cs" /> + <Compile Include="TestTypes\Person.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="packages.config" /> + <None Include="RazorEngine.snk" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\RazorEngine.Core\RazorEngine.Core.csproj"> + <Project>{D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}</Project> + <Name>RazorEngine.Core</Name> + </ProjectReference> + </ItemGroup> + <ItemGroup /> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/RazorEngineHostTestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,112 @@ +using RazorEngine.Tests.TestTypes.BaseTypes; + +namespace RazorEngine.Tests +{ + using System.Collections.Generic; + using System.Dynamic; + using System.Linq; + + using NUnit.Framework; + + using Compilation; + using Configuration; + using Templating; + using Text; + using TestTypes; + + /// <summary> + /// Defines a test fixture that provides tests for the <see cref="TemplateBase"/> type. + /// </summary> + [TestFixture] + public class RazorEngineHostTestFixture + { + #region Tests + /// <summary> + /// Tests that the <see cref="RazorEngineHost"/> supports the @model directive. + /// </summary> + /// <remarks> + /// As with it's MVC counterpart, we've added support for the @model declaration. This is to enable scenarios + /// where the model type might be unknown, but we can pass in an instance of <see cref="object" /> and allow + /// the @model directive to switch the model type. + /// </remarks> + [Test] + public void RazorEngineHost_SupportsModelSpan_UsingCSharpCodeParser() + { + using (var service = new TemplateService()) + { + const string template = "@model List<RazorEngine.Tests.TestTypes.Person>\n@Model.Count"; + const string expected = "1"; + + var model = new List<Person> { new Person() { Forename = "Matt", Age = 27 } }; + string result = service.Parse(template, (object)model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + [Test] + public void RazorEngineHost_SupportsModelSpan_WithBaseType_NotGeneric_UsingCSharpCodeParser() + { + var config = new TemplateServiceConfiguration(); + config.BaseTemplateType = typeof(TemplateBase); + using (var service = new TemplateService(config)) + { + const string template = "@model RazorEngine.Tests.TestTypes.Person\n@Model.Forename"; + const string expected = "Matt"; + + var model = new Person {Forename = "Matt"}; + string result = service.Parse(template, (object)model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that the <see cref="RazorEngineHost"/> supports the @ModelType directive. + /// </summary> + /// <remarks> + /// As with it's MVC counterpart, we've added support for the @ModelType declaration. This is to enable scenarios + /// where the model type might be unknown, but we can pass in an instance of <see cref="object" /> and allow + /// the @model directive to switch the model type. + /// </remarks> + [Test] + public void RazorEngineHost_SupportsModelSpan_UsingVBCodeParser() + { + var config = new TemplateServiceConfiguration + { + Language = Language.VisualBasic + }; + + using (var service = new TemplateService(config)) + { + const string template = "@ModelType List(Of RazorEngine.Tests.TestTypes.Person)\n@Model.Count"; + const string expected = "1"; + + var model = new List<Person> { new Person() { Forename = "Matt", Age = 27 } }; + string result = service.Parse(template, (object)model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + [Test] + public void RazorEngineHost_SupportsModelSpan_WithBaseType_NotGeneric_UsingVBCodeParser() + { + var config = new TemplateServiceConfiguration(); + config.BaseTemplateType = typeof(TemplateBase); + config.Language = Language.VisualBasic; + + using (var service = new TemplateService(config)) + { + const string template = "@ModelType List(Of RazorEngine.Tests.TestTypes.Person)\n@Model.Count"; + const string expected = "1"; + + var model = new List<Person> { new Person() { Forename = "Matt", Age = 27 } }; + string result = service.Parse(template, (object)model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TemplateBaseTestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,181 @@ +namespace RazorEngine.Tests +{ + using System.Collections.Generic; + using System.Dynamic; + using System.Linq; + + using NUnit.Framework; + + using Configuration; + using Templating; + using Text; + using TestTypes; + + /// <summary> + /// Defines a test fixture that provides tests for the <see cref="TemplateBase"/> type. + /// </summary> + [TestFixture] + public class TemplateBaseTestFixture + { + #region Tests + /// <summary> + /// Tests that a call to <see cref="TemplateBase.Raw" /> will output the raw text when using html encoding. + /// </summary> + /// <remarks> + /// <see cref="TemplateBase"/> includes a <see cref="TemplateBase.Raw"/> method which returns an instance of + /// <see cref="RawString"/> which should bypass the string encoding when writing values. + /// </remarks> + [Test] + public void TemplateBase_CanUseRawOutput_WithHtmlEncoding() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Raw(Model.Name)</h1>"; + const string expected = "<h1>Hello <</h1>"; + + var model = new { Name = "<" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a template can support a layout. + /// </summary> + [Test] + public void TemplateBase_CanRenderWithLayout_WithSimpleLayout() + { + using (var service = new TemplateService()) + { + const string parent = @"<div>@RenderSection(""TestSection"")</div>@RenderBody()"; + const string template = @"@{Layout = ""Parent"";}@section TestSection {<span>Hello</span>}<h1>Hello World</h1>"; + const string expected = "<div><span>Hello</span></div><h1>Hello World</h1>"; + + /* GetTemplate is the simplest method for compiling and caching a template without using a + * resolver to locate the layout template at a later time in exection. */ + service.GetTemplate(parent, null, "Parent"); + string result = service.Parse(template, null, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a template can support a layout. This test uses multiple layout templates in the template hierachy, + /// and the end result should put child content in both the outer layout (grandparent), and in the inner layout (parent). + /// </summary> + /// <remarks> + /// Outer layout (grandparent): + /// <div>Message from Child Template (section): @RenderSection("ChildMessage")</div> + /// <div>Message from Parent Template (section): @RenderSection("ParentMessage")</div> + /// <div>Content from Parent Template (body): @RenderBody()</div> + /// + /// Inner layout (parent): + /// @{ + /// Layout = "GrandParent"; + /// } + /// @section ParentMessage { + /// <span>Hello from Parent</span> + /// } + /// <p>Child content: @RenderBody()</p> + /// + /// Template (child): + /// @{ + /// Layout = "Parent"; + /// } + /// @section ChildMessage { + /// <span>Hello from Child</span> + /// } + /// <p>This is child content</p> + /// + /// Expected result: + /// <div>Message from Child Template (section): + /// <span>Hello from Child</span> + /// </div> + /// <div>Message from Parent Template (section): + /// <span>Hello from Parent</span> + /// </div> + /// <div>Content from Parent Template (body): + /// <p>Child content: <p>This is child content</p></p> + /// </div> + /// </remarks> + [Test] + public void TemplateBase_CanRenderWithLayout_WithComplexLayout() + { + using (var service = new TemplateService()) + { + const string grandparent = @"<div>Message from Child Template (section): @RenderSection(""ChildMessage"")</div><div>Message from Parent Template (section): @RenderSection(""ParentMessage"")</div><div>Content from Parent Template (body): @RenderBody()</div>"; + const string parent = @"@{Layout = ""GrandParent"";}@section ParentMessage {<span>Hello from Parent</span>}<p>Child content: @RenderBody()</p>"; + const string template = @"@{Layout = ""Parent"";}@section ChildMessage {<span>Hello from Child</span>}<p>This is child content</p>"; + const string expected = "<div>Message from Child Template (section): <span>Hello from Child</span></div><div>Message from Parent Template (section): <span>Hello from Parent</span></div><div>Content from Parent Template (body): <p>Child content: <p>This is child content</p></p></div>"; + + service.GetTemplate(parent, null, "Parent"); + service.GetTemplate(grandparent, null, "GrandParent"); + string result = service.Parse(template, null, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a template service can include another template. + /// </summary> + [Test] + public void TemplateBase_CanRenderWithInclude_SimpleInclude() + { + using (var service = new TemplateService()) + { + const string child = "<div>Content from child</div>"; + const string template = "@Include(\"Child\")"; + const string expected = "<div>Content from child</div>"; + + service.GetTemplate(child, null, "Child"); + string result = service.Parse(template, null, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a template service can include another template with current templete model if it was not specified. + /// </summary> + [Test] + public void TemplateBase_CanRenderWithInclude_WithCurrentModel() + { + using (var service = new TemplateService()) + { + const string child = "@model RazorEngine.Tests.TestTypes.Person\n<div>Content from child for @Model.Forename</div>"; + const string template = "@model RazorEngine.Tests.TestTypes.Person\n@Include(\"Child\")"; + const string expected = "<div>Content from child for Test</div>"; + var person = new Person { Forename = "Test" }; + + service.GetTemplate(child, person, "Child"); + string result = service.Parse(template, person, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a template service can include another template with current templete model if it was not specified. + /// </summary> + [Test] + public void TemplateBase_CanRenderWithInclude_WithCustomModel() + { + using (var service = new TemplateService()) + { + const string child = "@model RazorEngine.Tests.TestTypes.Person\n<div>Content from child for @Model.Forename</div>"; + const string template = "@Include(\"Child\", new RazorEngine.Tests.TestTypes.Person { Forename = \"Test\" })"; + const string expected = "<div>Content from child for Test</div>"; + + service.GetTemplate(child, null, "Child"); + string result = service.Parse(template, null, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TemplateServiceTestFixture.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,554 @@ +using System; +using RazorEngine.Tests.TestTypes.BaseTypes; + +namespace RazorEngine.Tests +{ + using System.Collections.Generic; + using System.Dynamic; + using System.Linq; + using System.Threading; + + using NUnit.Framework; + + using Configuration; + using Templating; + using Text; + using TestTypes; + + /// <summary> + /// Defines a test fixture that provides tests for the <see cref="TemplateService"/> type. + /// </summary> + [TestFixture] + public class TemplateServiceTestFixture + { + #region Tests + /// <summary> + /// Tests that a simple template without a model can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleTemplate_WithNoModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello World</h1>"; + const string expected = template; + + string result = service.Parse(template, null, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with a model can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleTemplate_WithComplexModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + const string expected = "<h1>Hello Matt</h1>"; + + var model = new Person { Forename = "Matt" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with an anonymous model can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleTemplate_WithAnonymousModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + const string expected = "<h1>Hello Matt</h1>"; + + var model = new { Forename = "Matt" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with a expando model can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleTemplate_WithExpandoModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + const string expected = "<h1>Hello Matt</h1>"; + + dynamic model = new ExpandoObject(); + model.Forename = "Matt"; + + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with a dynamic model can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleTemplate_WithDynamicModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + const string expected = "<h1>Hello Matt</h1>"; + + dynamic model = new ValueObject(new Dictionary<string, object> { { "Forename", "Matt" } }); + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with an iterator model can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleTemplate_WithIteratorModel() + { + using (var service = new TemplateService()) + { + const string template = "@foreach (var i in Model) { @i }"; + const string expected = "One Two Three"; + + var model = CreateIterator("One ", "Two ", "Three"); + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + private static IEnumerable<T> CreateIterator<T>(params T[] items) + { + foreach (var item in items) yield return item; + } + + /// <summary> + /// Tests that a simple template with html-encoding can be parsed. + /// </summary> + /// <remarks> + /// Text encoding is performed when writing objects to the template result (not literals). This test should + /// show that the template service is correctly providing the appropriate encoding factory to process + /// the object's .ToString() and automatically encode it. + /// </remarks> + [Test] + public void TemplateService_CanParseSimpleTemplate_UsingHtmlEncoding() + { + + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.String</h1>"; + const string expected = "<h1>Hello Matt & World</h1>"; + + var model = new { String = "Matt & World" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple template with no-encoding can be parsed. + /// </summary> + /// <remarks> + /// Text encoding is performed when writing objects to the template result (not literals). This test should + /// show that the template service is correctly providing the appropriate encoding factory to process + /// the object's .ToString() and automatically encode it. + /// </remarks> + [Test] + public void TemplateService_CanParseSimpleTemplate_UsingRawEncoding() + { + var config = new TemplateServiceConfiguration() + { + EncodedStringFactory = new RawStringFactory() + }; + + using (var service = new TemplateService(config)) + { + const string template = "<h1>Hello @Model.String</h1>"; + const string expected = "<h1>Hello Matt & World</h1>"; + + var model = new { String = "Matt & World" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in sequence. + /// </summary> + [Test] + public void TemplateService_CanParseMultipleTemplatesInSequence_WitNoModels() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello World</h1>"; + var templates = Enumerable.Repeat(template, 10); + + var results = service.ParseMany(templates, null, null, null, false); + + Assert.That(templates.SequenceEqual(results), "Rendered templates do not match expected."); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in parallel. + /// </summary> + [Test] + public void TemplateService_CanParseMultipleTemplatesInParallel_WitNoModels() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello World</h1>"; + var templates = Enumerable.Repeat(template, 10); + + var results = service.ParseMany(templates, null, null, null, true); + + Assert.That(templates.SequenceEqual(results), "Rendered templates do not match expected."); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in sequence with complex models. + /// </summary> + [Test] + public void TemplateService_CanParseMultipleTemplatesInSequence_WithComplexModels() + { + const int maxTemplates = 10; + + using (var service = new TemplateService()) + { + const string template = "<h1>Age: @Model.Age</h1>"; + var expected = Enumerable.Range(1, maxTemplates).Select(i => string.Format("<h1>Age: {0}</h1>", i)); + var templates = Enumerable.Repeat(template, maxTemplates); + var models = Enumerable.Range(1, maxTemplates).Select(i => new Person { Age = i }); + + var results = service.ParseMany(templates, models, null, null, false); + Assert.That(expected.SequenceEqual(results), "Parsed templates do not match expected results."); + } + } + + /// <summary> + /// Tests that the template service can parse multiple templates in parallel with complex models. + /// </summary> + [Test] + public void TemplateService_CanParseMultipleTemplatesInParallel_WithComplexModels() + { + const int maxTemplates = 10; + + using (var service = new TemplateService()) + { + const string template = "<h1>Age: @Model.Age</h1>"; + var expected = Enumerable.Range(1, maxTemplates).Select(i => string.Format("<h1>Age: {0}</h1>", i)); + var templates = Enumerable.Repeat(template, maxTemplates); + var models = Enumerable.Range(1, maxTemplates).Select(i => new Person { Age = i }); + + var results = service.ParseMany(templates, models, null, null, true); + Assert.That(expected.SequenceEqual(results), "Parsed templates do not match expected results."); + } + } + + /// <summary> + /// Tests that the template service can parse templates when using a manual threading model (i.e. manually creating <see cref="Thread"/> + /// instances and maintaining their lifetime. + /// </summary> + [Test] + public void TemplateService_CanParseTemplatesInParallel_WithManualThreadModel() + { + var service = new TemplateService(); + + const int threadCount = 10; + const string template = "<h1>Hello you are @Model.Age</h1>"; + + var threads = new List<Thread>(); + for (int i = 0; i < threadCount; i++) + { + // Capture enumerating index here to avoid closure issues. + int index = i; + + var thread = new Thread(() => + { + var model = new Person { Age = index }; + string expected = "<h1>Hello you are " + index + "</h1>"; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + }); + + threads.Add(thread); + thread.Start(); + } + + // Block until all threads have joined. + threads.ForEach(t => t.Join()); + + service.Dispose(); + } + + /// <summary> + /// Tests that the template service can parse templates when using the threadpool. + /// </summary> + [Test] + public void TemplateService_CanParseTemplatesInParallel_WithThreadPool() + { + var service = new TemplateService(); + + const int count = 10; + const string template = "<h1>Hello you are @Model.Age</h1>"; + + /* As we are leaving the threading to the pool, we need a way of coordinating the execution + * of the test after the threadpool has done its work. ManualResetEvent instances are the way. */ + var resetEvents = new ManualResetEvent[count]; + for (int i = 0; i < count; i++) + { + // Capture enumerating index here to avoid closure issues. + int index = i; + + string expected = "<h1>Hello you are " + index + "</h1>"; + resetEvents[index] = new ManualResetEvent(false); + + var model = new Person { Age = index }; + var item = new ThreadPoolItem<Person>(model, resetEvents[index], m => + { + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + }); + + ThreadPool.QueueUserWorkItem(item.ThreadPoolCallback); + } + + // Block until all events have been set. + WaitHandle.WaitAll(resetEvents); + + service.Dispose(); + } + + /// <summary> + /// Tests that a template service can precompile a template for later execution. + /// </summary> + [Test] + public void TemplateService_CanPrecompileTemplate_WithNoModel() + { + using (var service = new TemplateService()) + { + const string template = "Hello World"; + const string expected = "Hello World"; + + service.Compile(template, null, "test"); + + string result = service.Run("test", null, null); + + Assert.That(result == expected, "Result does not match expected."); + } + } + + /// <summary> + /// Tests that a template service can precompile a template with a non generic base for later execution. + /// </summary> + [Test] + public void TemplateService_CanPrecompileTemplate_WithNoModelAndANonGenericBase() + { + var config = new TemplateServiceConfiguration {BaseTemplateType = typeof (NonGenericTemplateBase)}; + using (var service = new TemplateService(config)) + { + const string template = "<h1>@GetHelloWorldText()</h1>"; + const string expected = "<h1>Hello World</h1>"; + + service.Compile(template, null, "test"); + + string result = service.Run("test", null, null); + Assert.That(result == expected, "Result does not match expected."); + } + } + + /// <summary> + /// Tests that a template service can precompile a template for later execution. + /// </summary> + [Test] + public void TemplateService_CanPrecompileTemplate_WithSimpleModel() + { + using (var service = new TemplateService()) + { + const string template = "Hello @Model.Forename"; + const string expected = "Hello Matt"; + + var model = new Person { Forename = "Matt" }; + + service.Compile(template, typeof(Person), "test"); + + string result = service.Run("test", model, null); + + Assert.That(result == expected, "Result does not match expected."); + } + } + + /// <summary> + /// Tests that a simple helper template with html-encoding can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleHelperTemplate_UsingHtmlEncoding() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @NameHelper()</h1>@helper NameHelper() { @Model.String }"; + const string expected = "<h1>Hello Matt & World</h1>"; + + var model = new { String = "Matt & World" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a simple helper template with no-encoding can be parsed. + /// </summary> + [Test] + public void TemplateService_CanParseSimpleHelperTemplate_UsingRawEncoding() + { + var config = new TemplateServiceConfiguration() + { + EncodedStringFactory = new RawStringFactory() + }; + + using (var service = new TemplateService(config)) + { + const string template = "<h1>Hello @NameHelper()</h1>@helper NameHelper() { @Model.String }"; + const string expected = "<h1>Hello Matt & World</h1>"; + + var model = new { String = "Matt & World" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + [Test] + public void TemplateService_CanParseSimpleTemplate_WithCorrectBaseTypeFromModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>Hello @Model.Forename</h1>"; + + var model = new Person { Forename = "Matt" }; + var templateInstance = service.CreateTemplate(template, null, model); + + Assert.NotNull(templateInstance as ITemplate<Person>, "Template is not derived from the correct base type"); + } + } + + [Test] + public void TemplateService_CanParseSimpleTemplate_WithNonGenericBaseType() + { + var config = new TemplateServiceConfiguration { BaseTemplateType = typeof(NonGenericTemplateBase) }; + using (var service = new TemplateService(config)) + { + const string template = "<h1>@GetHelloWorldText()</h1>"; + + var templateInstance = service.CreateTemplate(template, null, null); + + Assert.NotNull(templateInstance as NonGenericTemplateBase, "Template is not derived from the correct base type"); + } + } + + [Test] + public void TemplateService_CanParseSimpleTemplate_UsingLinqExtensionMethodOnArrayTypeModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>There are @Model.Take(2).ToList().Count() animals</h1>"; + const string expected = "<h1>There are 2 animals</h1>"; + + var model = new[] {new Animal {Type = "Cat"}, new Animal {Type = "Dog"}}; + + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + [Test] + public void TemplateService_CanParseSimpleTemplate_UsingLinqExtensionMethodOnArrayTypeFromModel() + { + using (var service = new TemplateService()) + { + const string template = "<h1>There are @Model.Animals.Take(2).ToList().Count() animals</h1>"; + const string expected = "<h1>There are 2 animals</h1>"; + + var model = new AnimalViewModel + { + Animals = new[] {new Animal {Type = "Cat"}, new Animal {Type = "Dog"}} + }; + + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a tilde is expanded with html-encoding. + /// </summary> + [Test] + public void TemplateService_CanParseTildeInTemplate_UsingHtmlEncoding() { + using (var service = new TemplateService()) { + const string template = "<a href=\"~/index.html\">@Model.String</a>"; + const string expected = "<a href=\"/index.html\">Matt</a>"; + + var model = new { String = "Matt" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// Tests that a tilde is expanded with no-encoding. + /// </summary> + [Test] + public void TemplateService_CanParseTildeInTemplate_UsingRawEncoding() { + var config = new TemplateServiceConfiguration() { + EncodedStringFactory = new RawStringFactory() + }; + + using (var service = new TemplateService(config)) { + const string template = "<a href=\"~/index.html\">@Model.String</a>"; + const string expected = "<a href=\"/index.html\">Matt</a>"; + + var model = new { String = "Matt" }; + string result = service.Parse(template, model, null, null); + + Assert.That(result == expected, "Result does not match expected: " + result); + } + } + + /// <summary> + /// When template uses layout but that layout is not specified in cache or by resolver, fail with a meaningful exception + /// </summary> + [Test] + public void TemplateBase_ParseWithLayout_WithoutPrecompiling() + { + using (var service = new TemplateService()) + { + var template = @"@{Layout = ""Layout"";} @section Body {Test}"; + Assert.Throws<ArgumentException>(() => service.Parse(template, null, null, null)); + } + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Activation/CustomTemplateBase.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,43 @@ +namespace RazorEngine.Tests.TestTypes.Activation +{ + using System; + + using Templating; + + /// <summary> + /// Defines a test template base. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + public class CustomTemplateBase<T> : TemplateBase<T> + { + #region Fields + private readonly ITextFormatter _formatter; + #endregion + + #region Methods + /// <summary> + /// Initialises a new instance of <see cref="CustomTemplateBase{T}"/> + /// </summary> + /// <param name="formatter">The formatter.</param> + public CustomTemplateBase(ITextFormatter formatter) + { + if (formatter == null) + throw new ArgumentNullException("formatter"); + + _formatter = formatter; + } + #endregion + + #region Methods + /// <summary> + /// Formats the specified object. + /// </summary> + /// <param name="value">The value to format.</param> + /// <returns>The string formatted value.</returns> + public string Format(object value) + { + return _formatter.Format(value.ToString()); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Activation/ITextFormatter.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,17 @@ +namespace RazorEngine.Tests.TestTypes.Activation +{ + /// <summary> + /// Defines the required contract for implementing a text formatter. + /// </summary> + public interface ITextFormatter + { + #region Methods + /// <summary> + /// Formats the specified value. + /// </summary> + /// <param name="value">The value to format.</param> + /// <returns>The formatted value.</returns> + string Format(string value); + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Activation/ReverseTextFormatter.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,24 @@ +namespace RazorEngine.Tests.TestTypes.Activation +{ + using System; + + /// <summary> + /// Reverses the contents of the specified string, + /// </summary> + public class ReverseTextFormatter : ITextFormatter + { + #region Methods + /// <summary> + /// Formats the specified value. + /// </summary> + /// <param name="value">The value to format.</param> + /// <returns>The formatted value.</returns> + public string Format(string value) + { + char[] content = value.ToCharArray(); + Array.Reverse(content); + return new string(content); + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Activation/UnityTemplateActivator.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,44 @@ +namespace RazorEngine.Tests.TestTypes.Activation +{ + using System; + + using Microsoft.Practices.Unity; + + using Templating; + + /// <summary> + /// Defines an activator that supports Unity. + /// </summary> + public class UnityTemplateActivator : IActivator + { + #region Fields + private readonly UnityContainer _container; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="UnityTemplateActivator"/>. + /// </summary> + /// <param name="container">The unity container.</param> + public UnityTemplateActivator(UnityContainer container) + { + if (container == null) + throw new ArgumentNullException("container"); + + _container = container; + } + #endregion + + #region Methods + /// <summary> + /// Creates an instance of the specifed template. + /// </summary> + /// <param name="context">The instance context.</param> + /// <returns>An instance of <see cref="ITemplate"/>.</returns> + public ITemplate CreateInstance(InstanceContext context) + { + return (ITemplate)_container.Resolve(context.TemplateType); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Animal.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,15 @@ +namespace RazorEngine.Tests.TestTypes +{ + /// <summary> + /// Defines an animal. + /// </summary> + public class Animal + { + #region Properties + /// <summary> + /// Gets the animal type. + /// </summary> + public string Type { get; set; } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/AnimalViewModel.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,10 @@ +namespace RazorEngine.Tests.TestTypes +{ + /// <summary> + /// Defines a complex view model. + /// </summary> + public class AnimalViewModel + { + public Animal[] Animals { get; set; } + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/BaseTypes/NonGenericTemplateBase.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,12 @@ +using RazorEngine.Templating; + +namespace RazorEngine.Tests.TestTypes.BaseTypes +{ + public abstract class NonGenericTemplateBase : TemplateBase + { + public string GetHelloWorldText() + { + return "Hello World"; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Employee.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,15 @@ +namespace RazorEngine.Tests.TestTypes +{ + /// <summary> + /// Defines an employee. + /// </summary> + public class Employee : Person + { + #region Properties + /// <summary> + /// Gets or sets the department. + /// </summary> + public string Department { get; set; } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Inspectors/ThrowExceptionCodeInspector.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,30 @@ +namespace RazorEngine.Tests.TestTypes.Inspectors +{ + using System.CodeDom; + + using Compilation.Inspectors; + + /// <summary> + /// Defines a code inspector that will insert a throw statement into the generated code. + /// </summary> + public class ThrowExceptionCodeInspector : ICodeInspector + { + #region Methods + /// <summary> + /// Inspects the specified code unit. + /// </summary> + /// <param name="unit">The code unit.</param> + /// <param name="ns">The code namespace declaration.</param> + /// <param name="type">The code type declaration.</param> + /// <param name="executeMethod">The code method declaration for the Execute method.</param> + public void Inspect(CodeCompileUnit unit, CodeNamespace ns, CodeTypeDeclaration type, CodeMemberMethod executeMethod) + { + var statement = new CodeThrowExceptionStatement( + new CodeObjectCreateExpression( + new CodeTypeReference(typeof(System.InvalidOperationException)), new CodeExpression[] {})); + + executeMethod.Statements.Insert(0, statement); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/Person.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,28 @@ +namespace RazorEngine.Tests.TestTypes +{ + using System; + + /// <summary> + /// Defines a person. + /// </summary> + [Serializable] + public class Person + { + #region Properties + /// <summary> + /// Gets or sets the age. + /// </summary> + public int Age { get; set; } + + /// <summary> + /// Gets or sets the forename. + /// </summary> + public string Forename { get; set; } + + /// <summary> + /// Gets or sets the surname. + /// </summary> + public string Surname { get; set; } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/ThreadPoolItem.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,55 @@ +namespace RazorEngine.Tests.TestTypes +{ + using System; + using System.Threading; + + /// <summary> + /// Defines a thread pool item. + /// </summary> + /// <typeparam name="T">The model type.</typeparam> + public class ThreadPoolItem<T> + { + #region Fields + private readonly Action<T> _action; + #endregion + + #region Constructor + /// <summary> + /// Initialises a new instance of <see cref="ThreadPoolItem{T}"/>. + /// </summary> + /// <param name="model">The model instance.</param> + /// <param name="resetEvent">The reset event.</param> + /// <param name="action">The action to run.</param> + public ThreadPoolItem(T model, ManualResetEvent resetEvent, Action<T> action) + { + Model = model; + ResetEvent = resetEvent; + _action = action; + } + #endregion + + #region Methods + /// <summary> + /// The callback method invoked by the threadpool. + /// </summary> + /// <param name="state">Any current state.</param> + public void ThreadPoolCallback(object state) + { + _action(Model); + ResetEvent.Set(); + } + #endregion + + #region Properties + /// <summary> + /// Gets the model. + /// </summary> + public T Model { get; private set; } + + /// <summary> + /// Gets the reset event. + /// </summary> + public ManualResetEvent ResetEvent { get; private set; } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/TestTypes/ValueObject.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,33 @@ +namespace RazorEngine.Tests.TestTypes +{ + using System.Collections.Generic; + using System.Dynamic; + + public class ValueObject : DynamicObject + { + #region Fields + private readonly IDictionary<string, object> _values; + #endregion + + #region Constructor + public ValueObject(IDictionary<string, object> values) + { + _values = values; + } + #endregion + + #region Methods + public override bool TryGetMember(GetMemberBinder binder, out object result) + { + if (_values.ContainsKey(binder.Name)) + { + result = _values[binder.Name]; + return true; + } + + result = null; + return false; + } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Core/Tests/RazorEngine.Core.Tests/packages.config Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="utf-8"?> +<packages> + <package id="Moq" version="4.1.1309.1617" targetFramework="net45" /> + <package id="NUnit" version="2.6.3" targetFramework="net45" /> + <package id="Unity" version="3.0.1304.1" targetFramework="net45" /> +</packages> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Hosts/RazorEngine.Hosts.Console/App.config Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="utf-8" ?> +<configuration> + <startup> + <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /> + </startup> +</configuration> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Hosts/RazorEngine.Hosts.Console/Program.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,59 @@ +namespace RazorEngine.Hosts.Console +{ + using System; + using System.Linq; + + using Compilation; + using Templating; + + class Program + { + static void Main(string[] args) + { + CompilerServiceBuilder.SetCompilerServiceFactory(new DefaultCompilerServiceFactory()); + + using (var service = new TemplateService()) + { + const string template = "<h1>Age: @Model.Age</h1>"; + var expected = Enumerable.Range(1, 10).Select(i => string.Format("<h1>Age: {0}</h1>", i)).ToList(); + var templates = Enumerable.Repeat(template, 10).ToList(); + var models = Enumerable.Range(1, 10).Select(i => new Person { Age = i }); + + var results = service.ParseMany(templates, models, null, null, true).ToList(); + + for (int i = 0; i < 10; i++) + { + Console.WriteLine(templates[i]); + Console.WriteLine(expected[i]); + Console.WriteLine(results[i]); + } + } + + Console.ReadKey(); + } + } + + /// <summary> + /// Defines a person. + /// </summary> + [Serializable] + public class Person + { + #region Properties + /// <summary> + /// Gets or sets the age. + /// </summary> + public int Age { get; set; } + + /// <summary> + /// Gets or sets the forename. + /// </summary> + public string Forename { get; set; } + + /// <summary> + /// Gets or sets the surname. + /// </summary> + public string Surname { get; set; } + #endregion + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Hosts/RazorEngine.Hosts.Console/Properties/AssemblyInfo.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("RazorEngine.Hosts.Console")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("RazorEngine.Hosts.Console")] +[assembly: AssemblyCopyright("Copyright © 2013")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("037a08ca-030c-45f5-88a1-985c07a2468a")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")]
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Hosts/RazorEngine.Hosts.Console/RazorEngine.Hosts.Console.csproj Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,64 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProjectGuid>{BC7891A1-8459-4A69-A37C-F40824E28C70}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>RazorEngine.Hosts.Console</RootNamespace> + <AssemblyName>RazorEngine.Hosts.Console</AssemblyName> + <TargetFrameworkVersion>v4.5</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <PlatformTarget>AnyCPU</PlatformTarget> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <PlatformTarget>AnyCPU</PlatformTarget> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <ItemGroup> + <Reference Include="System" /> + <Reference Include="System.Core" /> + <Reference Include="System.Xml.Linq" /> + <Reference Include="System.Data.DataSetExtensions" /> + <Reference Include="Microsoft.CSharp" /> + <Reference Include="System.Data" /> + <Reference Include="System.Xml" /> + </ItemGroup> + <ItemGroup> + <Compile Include="Program.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="App.config" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\Core\RazorEngine.Core\RazorEngine.Core.csproj"> + <Project>{d268f86d-2dab-4329-a75f-3bcf6d5bcdc4}</Project> + <Name>RazorEngine.Core</Name> + </ProjectReference> + </ItemGroup> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/RazorEngine.sln Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,93 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.21005.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{CB08CC9C-1232-4F96-8A43-BFFA906D3DC8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RazorEngine.Core", "Core\RazorEngine.Core\RazorEngine.Core.csproj", "{D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Shared", "Shared", "{3BBC422C-2720-487E-B46E-BFED47165373}" + ProjectSection(SolutionItems) = preProject + Shared\RazorEngine.Public.snk = Shared\RazorEngine.Public.snk + Shared\RazorEngine.snk = Shared\RazorEngine.snk + Shared\SharedAssemblyInfo.cs = Shared\SharedAssemblyInfo.cs + EndProjectSection +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{736162F9-990C-4DDA-BDC6-7FBDEC0AA857}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RazorEngine.Core.Tests", "Core\Tests\RazorEngine.Core.Tests\RazorEngine.Core.Tests.csproj", "{F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Hosts", "Hosts", "{31645D9C-55C6-43F4-A3EB-380DD82B338E}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Web", "Web", "{8DA86295-C17B-4D67-8F94-E2463AD45459}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RazorEngine.Mvc", "Web\RazorEngine.Mvc\RazorEngine.Mvc.csproj", "{878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RazorEngine.Hosts.Console", "Hosts\RazorEngine.Hosts.Console\RazorEngine.Hosts.Console.csproj", "{BC7891A1-8459-4A69-A37C-F40824E28C70}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|Mixed Platforms = Debug|Mixed Platforms + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|Mixed Platforms = Release|Mixed Platforms + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Debug|x86.ActiveCfg = Debug|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Release|Any CPU.Build.0 = Release|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}.Release|x86.ActiveCfg = Release|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Debug|x86.ActiveCfg = Debug|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Release|Any CPU.Build.0 = Release|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E}.Release|x86.ActiveCfg = Release|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Debug|x86.ActiveCfg = Debug|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Release|Any CPU.Build.0 = Release|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}.Release|x86.ActiveCfg = Release|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Debug|x86.ActiveCfg = Debug|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Release|Any CPU.Build.0 = Release|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {BC7891A1-8459-4A69-A37C-F40824E28C70}.Release|x86.ActiveCfg = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4} = {CB08CC9C-1232-4F96-8A43-BFFA906D3DC8} + {736162F9-990C-4DDA-BDC6-7FBDEC0AA857} = {CB08CC9C-1232-4F96-8A43-BFFA906D3DC8} + {F4F5AB5F-BF81-4C0C-8F2E-68AB02160C4E} = {736162F9-990C-4DDA-BDC6-7FBDEC0AA857} + {BC7891A1-8459-4A69-A37C-F40824E28C70} = {31645D9C-55C6-43F4-A3EB-380DD82B338E} + {878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4} = {8DA86295-C17B-4D67-8F94-E2463AD45459} + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EnterpriseLibraryConfigurationToolBinariesPath = packages\Unity.2.1.505.0\lib\NET35 + EndGlobalSection +EndGlobal
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Shared/SharedAssemblyInfo.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,17 @@ +using System; +using System.Reflection; + +#if DEBUG +[assembly: AssemblyConfiguration("Debug")] +#else +[assembly: AssemblyConfiguration("Release")] +#endif +[assembly: AssemblyCompany("RazorEngine Project")] + +[assembly: AssemblyProduct("RazorEngine")] +[assembly: AssemblyCopyright("Copyright © RazorEngine Project 2011-2013")] + +[assembly: AssemblyVersion("3.5.0.0")] +[assembly: AssemblyFileVersion("3.5.0.0")] + +//[assembly: CLSCompliant(true)] \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Web/RazorEngine.Mvc/MvcTemplateBase.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,36 @@ +namespace RazorEngine.Mvc +{ + using System; + using System.Web; + using System.Web.Mvc; + + using Templating; + + /// <summary> + /// Provides a base implementation of an MVC-compatible template. + /// </summary> + public abstract class MvcTemplateBase : TemplateBase + { + #region Properties + /// <summary> + /// Gets the <see cref="HtmlHelper{Object}"/> for this template. + /// </summary> + public HtmlHelper<object> Html { get; private set; } + + /// <summary> + /// Gets the <see cref="UrlHelper"/> for this template. + /// </summary> + public UrlHelper Url { get; private set; } + #endregion + + #region Methods + public void InitHelpers() + { + var httpContext = new HttpContextWrapper(HttpContext.Current); + var handler = httpContext.CurrentHandler as MvcHandler; + if (handler == null) + throw new InvalidOperationException("Unable to run template outside of ASP.NET MVC"); + } + #endregion + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Web/RazorEngine.Mvc/Properties/AssemblyInfo.cs Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("RazorEngine.Mvc")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("RazorEngine.Mvc")] +[assembly: AssemblyCopyright("Copyright © 2011")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("e6e3699c-9a7a-4ac8-9b48-fa8292240f0b")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")]
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Web/RazorEngine.Mvc/RazorEngine.Mvc.csproj Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,61 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>8.0.30703</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{878A8554-ACF1-4A0B-9BFC-6BD5FC5048C4}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>RazorEngine.Mvc</RootNamespace> + <AssemblyName>RazorEngine.Mvc</AssemblyName> + <TargetFrameworkVersion>v4.5</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <TargetFrameworkProfile /> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + <Prefer32Bit>false</Prefer32Bit> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + <Prefer32Bit>false</Prefer32Bit> + </PropertyGroup> + <ItemGroup> + <Reference Include="System" /> + <Reference Include="System.Core" /> + <Reference Include="System.Web" /> + <Reference Include="System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" /> + <Reference Include="Microsoft.CSharp" /> + </ItemGroup> + <ItemGroup> + <Compile Include="MvcTemplateBase.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\Core\RazorEngine.Core\RazorEngine.Core.csproj"> + <Project>{D268F86D-2DAB-4329-A75F-3BCF6D5BCDC4}</Project> + <Name>RazorEngine.Core</Name> + </ProjectReference> + </ItemGroup> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project> \ No newline at end of file
Binary file src/packages/Microsoft.AspNet.Razor.3.0.0/Microsoft.AspNet.Razor.3.0.0.nupkg has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Microsoft.AspNet.Razor.3.0.0/Microsoft.AspNet.Razor.3.0.0.nuspec Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,19 @@ +<?xml version="1.0"?> +<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd"> + <metadata> + <id>Microsoft.AspNet.Razor</id> + <version>3.0.0</version> + <title>Microsoft ASP.NET Razor</title> + <authors>Microsoft</authors> + <owners>Microsoft</owners> + <licenseUrl>http://www.microsoft.com/web/webpi/eula/aspnetcomponent_rtw_ENU.htm</licenseUrl> + <projectUrl>http://www.asp.net/web-pages</projectUrl> + <requireLicenseAcceptance>true</requireLicenseAcceptance> + <description>This package contains the runtime assemblies for ASP.NET Web Pages. ASP.NET Web Pages and the new Razor syntax provide a fast, terse, clean and lightweight way to combine server code with HTML to create dynamic web content.</description> + <summary>This package contains the runtime assemblies for ASP.NET Web Pages.</summary> + <releaseNotes /> + <copyright>© Microsoft Corporation. All rights reserved.</copyright> + <language>en-US</language> + <tags>Microsoft AspNet WebPages AspNetWebPages Razor</tags> + </metadata> +</package> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Microsoft.AspNet.Razor.3.0.0/lib/net45/System.Web.Razor.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,5738 @@ +<?xml version="1.0" encoding="utf-8"?> +<doc> + <assembly> + <name>System.Web.Razor</name> + </assembly> + <members> + <member name="T:System.Web.Razor.CSharpRazorCodeLanguage"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a Razor code language that is based on C# syntax.</summary> + </member> + <member name="M:System.Web.Razor.CSharpRazorCodeLanguage.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.CSharpRazorCodeLanguage" /> class.</summary> + </member> + <member name="P:System.Web.Razor.CSharpRazorCodeLanguage.CodeDomProviderType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the type of the code provider.</summary> + <returns>The type of the code provider.</returns> + </member> + <member name="M:System.Web.Razor.CSharpRazorCodeLanguage.CreateCodeGenerator(System.String,System.String,System.String,System.Web.Razor.RazorEngineHost)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a new Razor code generator based on C# code language.</summary> + <returns>The newly created Razor code generator based on C# code language.</returns> + <param name="className">The class name for the generated code.</param> + <param name="rootNamespaceName">The name of the root namespace for the generated code.</param> + <param name="sourceFileName">The name of the source code file.</param> + <param name="host">The Razor engine host.</param> + </member> + <member name="M:System.Web.Razor.CSharpRazorCodeLanguage.CreateCodeParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a new code parser for C# code language.</summary> + <returns>The newly created code parser for C# code language.</returns> + </member> + <member name="P:System.Web.Razor.CSharpRazorCodeLanguage.LanguageName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the name of the C# code language.</summary> + <returns>The name of the C# code language. Value is ‘csharp’.</returns> + </member> + <member name="T:System.Web.Razor.DocumentParseCompleteEventArgs"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.DocumentParseCompleteEventArgs.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.DocumentParseCompleteEventArgs.GeneratorResults"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.DocumentParseCompleteEventArgs.SourceChange"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.DocumentParseCompleteEventArgs.TreeStructureChanged"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.GeneratorResults"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents results from code generation.</summary> + </member> + <member name="M:System.Web.Razor.GeneratorResults.#ctor(System.Boolean,System.Web.Razor.Parser.SyntaxTree.Block,System.Collections.Generic.IList{System.Web.Razor.Parser.SyntaxTree.RazorError},System.CodeDom.CodeCompileUnit,System.Collections.Generic.IDictionary{System.Int32,System.Web.Razor.Generator.GeneratedCodeMapping})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.GeneratorResults" /> class.</summary> + <param name="success">true if the code generation is a success; otherwise, false.</param> + <param name="document">The document.</param> + <param name="parserErrors">The parser errors.</param> + <param name="generatedCode">The generated code.</param> + <param name="designTimeLineMappings">The dictionary of design-time generated code mappings.</param> + </member> + <member name="M:System.Web.Razor.GeneratorResults.#ctor(System.Web.Razor.Parser.SyntaxTree.Block,System.Collections.Generic.IList{System.Web.Razor.Parser.SyntaxTree.RazorError},System.CodeDom.CodeCompileUnit,System.Collections.Generic.IDictionary{System.Int32,System.Web.Razor.Generator.GeneratedCodeMapping})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.GeneratorResults" /> class.</summary> + <param name="document">The document.</param> + <param name="parserErrors">The parser errors.</param> + <param name="generatedCode">The generated code.</param> + <param name="designTimeLineMappings">The dictionary of design-time generated code mappings.</param> + </member> + <member name="M:System.Web.Razor.GeneratorResults.#ctor(System.Web.Razor.ParserResults,System.CodeDom.CodeCompileUnit,System.Collections.Generic.IDictionary{System.Int32,System.Web.Razor.Generator.GeneratedCodeMapping})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.GeneratorResults" /> class.</summary> + <param name="parserResults">The parser results.</param> + <param name="generatedCode">The generated code.</param> + <param name="designTimeLineMappings">The dictionary of design-time generated code mappings.</param> + </member> + <member name="P:System.Web.Razor.GeneratorResults.DesignTimeLineMappings"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the dictionary of design-time generated code mappings.</summary> + <returns>The dictionary of design-time generated code mappings.</returns> + </member> + <member name="P:System.Web.Razor.GeneratorResults.GeneratedCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the generated code.</summary> + <returns>The generated code.</returns> + </member> + <member name="T:System.Web.Razor.ParserResults"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the results of parsing a Razor document.</summary> + </member> + <member name="M:System.Web.Razor.ParserResults.#ctor(System.Boolean,System.Web.Razor.Parser.SyntaxTree.Block,System.Collections.Generic.IList{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.ParserResults" /> class.</summary> + <param name="success">true if parsing was successful; otherwise, false.</param> + <param name="document">The root node in the document’s syntax tree.</param> + <param name="errors">The list of errors which occurred during parsing.</param> + </member> + <member name="M:System.Web.Razor.ParserResults.#ctor(System.Web.Razor.Parser.SyntaxTree.Block,System.Collections.Generic.IList{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.ParserResults" /> class.</summary> + <param name="document">The root node in the document’s syntax tree.</param> + <param name="parserErrors">The list of errors which occurred during parsing.</param> + </member> + <member name="P:System.Web.Razor.ParserResults.Document"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the root node in the document’s syntax tree.</summary> + <returns>The root node in the document’s syntax tree.</returns> + </member> + <member name="P:System.Web.Razor.ParserResults.ParserErrors"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the list of errors which occurred during parsing.</summary> + <returns>The list of errors which occurred during parsing.</returns> + </member> + <member name="P:System.Web.Razor.ParserResults.Success"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value indicating whether parsing was successful.</summary> + <returns>true if parsing was successful; otherwise, false.</returns> + </member> + <member name="T:System.Web.Razor.PartialParseResult"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.PartialParseResult.Accepted"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.PartialParseResult.AutoCompleteBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.PartialParseResult.Provisional"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.PartialParseResult.Rejected"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.PartialParseResult.SpanContextChanged"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.RazorCodeLanguage"> + <summary>Represents the base for all Razor code language.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.RazorCodeLanguage.#ctor"> + <summary>Initializes a new instance of the <see cref="T:System.Web.Razor.RazorCodeLanguage" /> class.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.RazorCodeLanguage.CodeDomProviderType"> + <summary>Gets the type of the CodeDOM provider.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <returns>The type of the CodeDOM provider.</returns> + </member> + <member name="M:System.Web.Razor.RazorCodeLanguage.CreateCodeGenerator(System.String,System.String,System.String,System.Web.Razor.RazorEngineHost)"> + <summary>Creates the code generator for the Razor code language.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <returns>The code generator for the Razor code language.</returns> + <param name="className">The class name.</param> + <param name="rootNamespaceName">The name of the root namespace.</param> + <param name="sourceFileName">The source file name.</param> + <param name="host">The Razor engine host.</param> + </member> + <member name="M:System.Web.Razor.RazorCodeLanguage.CreateCodeParser"> + <summary>Creates the code parser for the Razor code language.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <returns>The code parser for the Razor code language.</returns> + </member> + <member name="M:System.Web.Razor.RazorCodeLanguage.GetLanguageByExtension(System.String)"> + <summary>Gets the language of the Razor code using the specified file extension.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <returns>The language of the Razor code.</returns> + <param name="fileExtension">The file extension.</param> + </member> + <member name="P:System.Web.Razor.RazorCodeLanguage.LanguageName"> + <summary>Gets the language name of the current Razor code, that is “csharp” or “vb”.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <returns>The language name of the current Razor code.</returns> + </member> + <member name="P:System.Web.Razor.RazorCodeLanguage.Languages"> + <summary>Gets the list of language supported by the Razor code.This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <returns>The list of language supported by the Razor code.</returns> + </member> + <member name="T:System.Web.Razor.RazorDirectiveAttribute"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents an attribute for the Razor directive.</summary> + </member> + <member name="M:System.Web.Razor.RazorDirectiveAttribute.#ctor(System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.RazorDirectiveAttribute" /> class.</summary> + <param name="name">The name of the attribute.</param> + <param name="value">The value of the attribute.</param> + </member> + <member name="M:System.Web.Razor.RazorDirectiveAttribute.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether this instance is equal to a specified object.</summary> + <returns>true if the object is equal to the this instance; otherwise, false.</returns> + <param name="obj">The object to compare with this instance.</param> + </member> + <member name="M:System.Web.Razor.RazorDirectiveAttribute.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="P:System.Web.Razor.RazorDirectiveAttribute.Name"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the name of the attribute.</summary> + <returns>The name of the attribute.</returns> + </member> + <member name="P:System.Web.Razor.RazorDirectiveAttribute.TypeId"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the unique type ID of the attribute.</summary> + <returns>The unique type ID of the attribute.</returns> + </member> + <member name="P:System.Web.Razor.RazorDirectiveAttribute.Value"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the value of the attribute.</summary> + <returns>The value of the attribute.</returns> + </member> + <member name="T:System.Web.Razor.RazorEditorParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parser used by editors to avoid reparsing the entire document on each text change.</summary> + </member> + <member name="M:System.Web.Razor.RazorEditorParser.#ctor(System.Web.Razor.RazorEngineHost,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Constructs the editor parser.</summary> + <param name="host">The <see cref="T:System.Web.Razor.RazorEngineHost" /> which defines the environment in which the generated code will live.</param> + <param name="sourceFileName">The physical path to use in line pragmas.</param> + </member> + <member name="M:System.Web.Razor.RazorEditorParser.CheckForStructureChanges(System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines if a change will cause a structural change to the document and if not, applies it to the existing tree. If a structural change would occur, automatically starts a reparse.</summary> + <returns>A <see cref="T:System.Web.Razor.PartialParseResult" /> value indicating the result of the incremental parse.</returns> + <param name="change">The change to apply to the parse tree.</param> + </member> + <member name="P:System.Web.Razor.RazorEditorParser.CurrentParseTree"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current parse tree.</summary> + <returns>The current parse tree.</returns> + </member> + <member name="M:System.Web.Razor.RazorEditorParser.Dispose"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Releases all resources used by the current instance of the <see cref="T:System.Web.Razor.RazorEditorParser" />.</summary> + </member> + <member name="M:System.Web.Razor.RazorEditorParser.Dispose(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Releases the unmanaged resources used by the <see cref="T:System.Web.Razor.RazorEditorParser" /> class and optionally releases the managed resources.</summary> + <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> + </member> + <member name="E:System.Web.Razor.RazorEditorParser.DocumentParseComplete"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Event fired when a full reparse of the document completes.</summary> + </member> + <member name="P:System.Web.Razor.RazorEditorParser.FileName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the filename of the document to parse.</summary> + <returns>The filename of the document to parse.</returns> + </member> + <member name="M:System.Web.Razor.RazorEditorParser.GetAutoCompleteString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Retrieves the auto complete string.</summary> + <returns>The auto complete string.</returns> + </member> + <member name="P:System.Web.Razor.RazorEditorParser.Host"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the host for the parse.</summary> + <returns>The host for the parse.</returns> + </member> + <member name="P:System.Web.Razor.RazorEditorParser.LastResultProvisional"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value indicating whether the last result of the parse was provisionally accepted for next partial parse.</summary> + <returns>true if the last result of the parse was provisionally accepted for next partial parse; otherwise, false.</returns> + </member> + <member name="T:System.Web.Razor.RazorEngineHost"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the generated code for the razor engine host.</summary> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.RazorEngineHost" /> class.</summary> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.#ctor(System.Web.Razor.RazorCodeLanguage)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.RazorEngineHost" /> class.</summary> + <param name="codeLanguage">The specified code language.</param> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.#ctor(System.Web.Razor.RazorCodeLanguage,System.Func{System.Web.Razor.Parser.ParserBase})"> + <summary>Initializes a new instance of the <see cref="T:System.Web.Razor.RazorEngineHost" /> class.</summary> + <param name="codeLanguage">The specified code language.</param> + <param name="markupParserFactory">The markup parser factory.</param> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.CodeLanguage"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the languages supported by the code generator.</summary> + <returns>The languages supported that by the code generator.</returns> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.CreateMarkupParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a markup parser using the specified language parser for the <see cref="T:System.Web.Razor.RazorEngineHost" />.</summary> + <returns>A markup parser to create using the specified language parser for the <see cref="T:System.Web.Razor.RazorEngineHost" />.</returns> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.DecorateCodeGenerator(System.Web.Razor.Generator.RazorCodeGenerator)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the methods as language-specific Razor code generator.</summary> + <returns>The methods as language-specific Razor code generator.</returns> + <param name="incomingCodeGenerator">The C# or Visual Basic code generator.</param> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.DecorateCodeParser(System.Web.Razor.Parser.ParserBase)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the methods as language-specific Razor code parser using the specified language parser.</summary> + <returns>The methods as language-specific Razor code parser using the specified language parser.</returns> + <param name="incomingCodeParser">The C# or Visual Basic code parser.</param> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.DecorateMarkupParser(System.Web.Razor.Parser.ParserBase)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the method to decorate markup parser using the specified language parser.</summary> + <returns>The method to decorate markup parser using the specified language parser.</returns> + <param name="incomingMarkupParser">The C# or Visual Basic code parser.</param> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.DefaultBaseClass"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the default base class for the host.</summary> + <returns>The default base class for the host.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.DefaultClassName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the default class name for the host.</summary> + <returns>The default class name for the host.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.DefaultNamespace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the default namespace for the host.</summary> + <returns>The default namespace for the host.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.DesignTimeMode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value that indicates whether the mode designs a time for the host.</summary> + <returns>true if the mode designs a time for the host; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.EnableInstrumentation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the host that enables the instrumentation.</summary> + <returns>The host that enables the instrumentation.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.GeneratedClassContext"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the generated class context for the host.</summary> + <returns>The generated class context for the host.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.InstrumentedSourceFilePath"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the instrumented source file path for the host.</summary> + <returns>The instrumented source file path for the host.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.IsIndentingWithTabs"></member> + <member name="P:System.Web.Razor.RazorEngineHost.NamespaceImports"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the namespace imports for the host.</summary> + <returns>The namespace imports for the host.</returns> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.PostProcessGeneratedCode(System.CodeDom.CodeCompileUnit,System.CodeDom.CodeNamespace,System.CodeDom.CodeTypeDeclaration,System.CodeDom.CodeMemberMethod)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns this method to post all the processed generated code for the host.</summary> + <param name="codeCompileUnit">The code compile unit.</param> + <param name="generatedNamespace">The generated namespace.</param> + <param name="generatedClass">The generated class.</param> + <param name="executeMethod">The execute method.</param> + </member> + <member name="M:System.Web.Razor.RazorEngineHost.PostProcessGeneratedCode(System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns this method to post all the processed generated code for the host.</summary> + <param name="context">The code generator context.</param> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.StaticHelpers"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the static helpers for the host.</summary> + <returns>The static helpers for the host.</returns> + </member> + <member name="P:System.Web.Razor.RazorEngineHost.TabSize"></member> + <member name="T:System.Web.Razor.RazorTemplateEngine"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents an entry-point to the Razor Template Engine.</summary> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.#ctor(System.Web.Razor.RazorEngineHost)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.RazorTemplateEngine" /> class.</summary> + <param name="host">The host.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.CreateCodeGenerator(System.String,System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a code generator.</summary> + <returns>The created <see cref="T:System.Web.Razor.Generator.RazorCodeGenerator" />.</returns> + <param name="className">The name of the generated class.</param> + <param name="rootNamespace">The namespace in which the generated class will reside.</param> + <param name="sourceFileName">The file name to use in line pragmas.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.CreateParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a <see cref="T:System.Web.Razor.Parser.RazorParser" />.</summary> + <returns>The created <see cref="T:System.Web.Razor.Parser.RazorParser" />.</returns> + </member> + <member name="F:System.Web.Razor.RazorTemplateEngine.DefaultClassName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the default class name of the template.</summary> + </member> + <member name="F:System.Web.Razor.RazorTemplateEngine.DefaultNamespace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the default namespace for the template.</summary> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.IO.TextReader)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.IO.TextReader,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.IO.TextReader,System.String,System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + <param name="className">The name of the generated class, overriding whatever is specified in the host.</param> + <param name="rootNamespace">The namespace in which the generated class will reside.</param> + <param name="sourceFileName">The file name to use in line pragmas.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.IO.TextReader,System.String,System.String,System.String,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + <param name="className">The name of the generated class, overriding whatever is specified in the host.</param> + <param name="rootNamespace">The namespace in which the generated class will reside.</param> + <param name="sourceFileName">The file name to use in line pragmas.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.Web.Razor.Text.ITextBuffer)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.Web.Razor.Text.ITextBuffer,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.Web.Razor.Text.ITextBuffer,System.String,System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + <param name="className">The name of the generated class, overriding whatever is specified in the host.</param> + <param name="rootNamespace">The namespace in which the generated class will reside.</param> + <param name="sourceFileName">The file name to use in line pragmas.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCode(System.Web.Razor.Text.ITextBuffer,System.String,System.String,System.String,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree.</summary> + <returns>The resulting parse tree AND generated Code DOM tree.</returns> + <param name="input">The input text to parse.</param> + <param name="className">The name of the generated class, overriding whatever is specified in the host.</param> + <param name="rootNamespace">The namespace in which the generated class will reside.</param> + <param name="sourceFileName">The file name to use in line pragmas.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.GenerateCodeCore(System.Web.Razor.Text.ITextDocument,System.String,System.String,System.String,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a code core.</summary> + <returns>The results of the generated core.</returns> + <param name="input">The input text to parse.</param> + <param name="className">The name of the generated class, overriding whatever is specified in the host.</param> + <param name="rootNamespace">The namespace in which the generated class will reside.</param> + <param name="sourceFileName">The file name to use in line pragmas.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="P:System.Web.Razor.RazorTemplateEngine.Host"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the <see cref="T:System.Web.Razor.RazorEngineHost" /> which defines the environment in which the generated template code will live.</summary> + <returns>The <see cref="T:System.Web.Razor.RazorEngineHost" /> which defines the environment in which the generated template code will live.</returns> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.ParseTemplate(System.IO.TextReader)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer and returns its result.</summary> + <returns>The resulting parse tree.</returns> + <param name="input">The input text to parse.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.ParseTemplate(System.IO.TextReader,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer and returns its result.</summary> + <returns>The resulting parse tree.</returns> + <param name="input">The input text to parse.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.ParseTemplate(System.Web.Razor.Text.ITextBuffer)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer and returns its result.</summary> + <returns>The resulting parse tree.</returns> + <param name="input">The input text to parse.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.ParseTemplate(System.Web.Razor.Text.ITextBuffer,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template specified by the TextBuffer and returns its result.</summary> + <returns>The resulting parse tree.</returns> + <param name="input">The input text to parse.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="M:System.Web.Razor.RazorTemplateEngine.ParseTemplateCore(System.Web.Razor.Text.ITextDocument,System.Nullable{System.Threading.CancellationToken})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the template core.</summary> + <returns>The resulting parse tree.</returns> + <param name="input">The input text to parse.</param> + <param name="cancelToken">A token used to cancel the parser.</param> + </member> + <member name="T:System.Web.Razor.StateMachine`1"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the state of the machine.</summary> + <typeparam name="TReturn">The generic type Return.</typeparam> + </member> + <member name="M:System.Web.Razor.StateMachine`1.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.StateMachine`1" /> class.</summary> + </member> + <member name="P:System.Web.Razor.StateMachine`1.CurrentState"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the current state of the machine.</summary> + <returns>The current state of the machine.</returns> + </member> + <member name="P:System.Web.Razor.StateMachine`1.StartState"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the starting state of the machine.</summary> + <returns>The starting state of the machine.</returns> + </member> + <member name="M:System.Web.Razor.StateMachine`1.Stay"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Stays into the machine during the transition.</summary> + <returns>Transition of the state machine.</returns> + </member> + <member name="M:System.Web.Razor.StateMachine`1.Stay(`0)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Stays into the machine during the transition with the specified output.</summary> + <returns>The output of the transition.</returns> + <param name="output">The output.</param> + </member> + <member name="M:System.Web.Razor.StateMachine`1.Stop"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Disables the machine upon transition.</summary> + <returns>The machine to stop.</returns> + </member> + <member name="M:System.Web.Razor.StateMachine`1.Transition(System.Web.Razor.StateMachine{`0}.State)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the new transition of the state.</summary> + <returns>The new transition of the state.</returns> + <param name="newState">The new state.</param> + </member> + <member name="M:System.Web.Razor.StateMachine`1.Transition(`0,System.Web.Razor.StateMachine{`0}.State)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the new transition of the state with the specified output.</summary> + <returns>The new transition of the state with the specified output.</returns> + <param name="output">The output.</param> + <param name="newState">The new state.</param> + </member> + <member name="M:System.Web.Razor.StateMachine`1.Turn"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Describes the turning process of the state.</summary> + <returns>The turning process of the state.</returns> + </member> + <member name="T:System.Web.Razor.StateMachine`1.State"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.StateMachine`1.StateResult"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the state result.</summary> + </member> + <member name="M:System.Web.Razor.StateMachine`1.StateResult.#ctor(System.Web.Razor.StateMachine{`0}.State)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.StateMachine`1.StateResult" /> class.</summary> + <param name="next">The next output.</param> + </member> + <member name="M:System.Web.Razor.StateMachine`1.StateResult.#ctor(`0,System.Web.Razor.StateMachine{`0}.State)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.StateMachine`1.StateResult" /> class.</summary> + <param name="output">The output.</param> + <param name="next">The next state.</param> + </member> + <member name="P:System.Web.Razor.StateMachine`1.StateResult.HasOutput"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value indicating whether the state has output.</summary> + <returns>true if the state has output; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.StateMachine`1.StateResult.Next"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the next state in the machine.</summary> + <returns>The next state in the machine.</returns> + </member> + <member name="P:System.Web.Razor.StateMachine`1.StateResult.Output"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the output.</summary> + <returns>The <see cref="T:System.Web.Razor.StateMachine`1.State" /> representing the output.</returns> + </member> + <member name="T:System.Web.Razor.VBRazorCodeLanguage"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a language generator and provider of the VB razor code.</summary> + </member> + <member name="M:System.Web.Razor.VBRazorCodeLanguage.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.VBRazorCodeLanguage" /> class.</summary> + </member> + <member name="P:System.Web.Razor.VBRazorCodeLanguage.CodeDomProviderType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the type of CodeDomProvider.</summary> + <returns>The type of CodeDomProvider.</returns> + </member> + <member name="M:System.Web.Razor.VBRazorCodeLanguage.CreateCodeGenerator(System.String,System.String,System.String,System.Web.Razor.RazorEngineHost)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates the code language generator.</summary> + <returns>The code language generator.</returns> + <param name="className">The name of the class.</param> + <param name="rootNamespaceName">The root namespace name.</param> + <param name="sourceFileName">The source File name.</param> + <param name="host">The <see cref="T:System.Web.Razor.RazorEngineHost" />.</param> + </member> + <member name="M:System.Web.Razor.VBRazorCodeLanguage.CreateCodeParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a code parser in a <see cref="T:System.Web.Razor.Parser.ParserBase" />.</summary> + <returns>A code parser in a <see cref="T:System.Web.Razor.Parser.ParserBase" />.</returns> + </member> + <member name="P:System.Web.Razor.VBRazorCodeLanguage.LanguageName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the language name.</summary> + <returns>The language name.</returns> + </member> + <member name="T:System.Web.Razor.Editor.EditorHints"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Editor.EditorHints.LayoutPage"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Editor.EditorHints.None"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Editor.EditorHints.VirtualPath"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Editor.EditResult"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the editing result of the Editor.</summary> + </member> + <member name="M:System.Web.Razor.Editor.EditResult.#ctor(System.Web.Razor.PartialParseResult,System.Web.Razor.Parser.SyntaxTree.SpanBuilder)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Editor.EditResult" /> class.</summary> + <param name="result">The partial parse result.</param> + <param name="editedSpan">The edited span builder.</param> + </member> + <member name="P:System.Web.Razor.Editor.EditResult.EditedSpan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the edited span of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.SpanBuilder" />.</summary> + <returns>The edited span of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.SpanBuilder" />.</returns> + </member> + <member name="P:System.Web.Razor.Editor.EditResult.Result"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the partial parse result.</summary> + <returns>The partial parse result.</returns> + </member> + <member name="T:System.Web.Razor.Editor.ImplicitExpressionEditHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Provides edit handler for implicit expression.</summary> + </member> + <member name="M:System.Web.Razor.Editor.ImplicitExpressionEditHandler.#ctor(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}},System.Collections.Generic.ISet{System.String},System.Boolean)"> + <summary>Initializes a new instance of the <see cref="T:System.Web.Razor.Editor.ImplicitExpressionEditHandler" /> class.</summary> + <param name="tokenizer">The tokenizer.</param> + <param name="keywords">The keywords.</param> + <param name="acceptTrailingDot">true to accept trailing dot; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Editor.ImplicitExpressionEditHandler.AcceptTrailingDot"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value indicating whether the expression accepts trailing dot.</summary> + <returns>true if the expression accepts trailing dot; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Editor.ImplicitExpressionEditHandler.CanAcceptChange(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the parse that can accept change.</summary> + <returns>The partial parse result.</returns> + <param name="target">The target.</param> + <param name="normalizedChange">The normalized change.</param> + </member> + <member name="M:System.Web.Razor.Editor.ImplicitExpressionEditHandler.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current objet; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Editor.ImplicitExpressionEditHandler.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Retrieves the hash code for this current instance.</summary> + <returns>The hash code for this current instance.</returns> + </member> + <member name="P:System.Web.Razor.Editor.ImplicitExpressionEditHandler.Keywords"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the keywords associated with the expression.</summary> + <returns>The keywords associated with the expression.</returns> + </member> + <member name="M:System.Web.Razor.Editor.ImplicitExpressionEditHandler.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of this current instance.</summary> + <returns>A string representation of this current instance.</returns> + </member> + <member name="T:System.Web.Razor.Editor.SingleLineMarkupEditHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the handler editor for this webpages.</summary> + </member> + <member name="M:System.Web.Razor.Editor.SingleLineMarkupEditHandler.#ctor(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}})"> + <summary>Initializes a new instance of the <see cref="T:System.Web.Razor.Editor.SingleLineMarkupEditHandler" /> class.</summary> + <param name="tokenizer">The tokenizer symbols.</param> + </member> + <member name="M:System.Web.Razor.Editor.SingleLineMarkupEditHandler.#ctor(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}},System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters)"> + <summary>Initializes a new instance of the <see cref="T:System.Web.Razor.Editor.SingleLineMarkupEditHandler" /> class.</summary> + <param name="tokenizer">The tokenizer symbols.</param> + <param name="accepted">The accepted characters.</param> + </member> + <member name="T:System.Web.Razor.Editor.SpanEditHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Provides methods for handling the span edits.</summary> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.#ctor(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Editor.SpanEditHandler" /> class.</summary> + <param name="tokenizer">The method used to parse string into tokens.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.#ctor(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}},System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Editor.SpanEditHandler" /> class.</summary> + <param name="tokenizer">The method used to parse string into tokens.</param> + <param name="accepted">One of the values of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters" /> enumeration.</param> + </member> + <member name="P:System.Web.Razor.Editor.SpanEditHandler.AcceptedCharacters"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets a value that specifies the accepted characters.</summary> + <returns>One of the values of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters" /> enumeration.</returns> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.ApplyChange(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Applies the text change to the span.</summary> + <returns>The result of the apply operation.</returns> + <param name="target">The span to apply changes to.</param> + <param name="change">The change to apply.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.ApplyChange(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Applies the text change to the span.</summary> + <returns>The result of the apply operation.</returns> + <param name="target">The span to apply changes to.</param> + <param name="change">The change to apply.</param> + <param name="force">true to accept partial result; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.CanAcceptChange(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the span can accept the specified change.</summary> + <returns>true if the span can accept the specified change; otherwise, false.</returns> + <param name="target">The span to check.</param> + <param name="normalizedChange">The change to apply.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.CreateDefault"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a new default span edit handler.</summary> + <returns>A newly created default span edit handler.</returns> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.CreateDefault(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a new default span edit handler.</summary> + <returns>A newly created default span edit handler.</returns> + <param name="tokenizer">The method used to parse string into tokens.</param> + </member> + <member name="P:System.Web.Razor.Editor.SpanEditHandler.EditorHints"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the editor hints.</summary> + <returns>The editor hints.</returns> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether this instance is equal to a specified object.</summary> + <returns>true if the object is equal to the this instance; otherwise, false.</returns> + <param name="obj">The object to compare with this instance.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.GetOldText(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the old text from the span content.</summary> + <returns>The old text from the span content.</returns> + <param name="target">The span to get old text from.</param> + <param name="change">The text change which contains the location of the old text.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.IsAtEndOfFirstLine(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified change is at the end of first line of the span content.</summary> + <returns>true if the specified change is at the end of first line of the span content; otherwise, false.</returns> + <param name="target">The span to check.</param> + <param name="change">The change to check.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.IsAtEndOfSpan(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified change is at the end of the span.</summary> + <returns>true if the specified change is at the end of the span; otherwise, false.</returns> + <param name="target">The span to check.</param> + <param name="change">The change to chek.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.IsEndDeletion(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified change is at the end the span content and for deletion.</summary> + <returns>true if the specified change is at the end the span content and for deletion; otherwise, false.</returns> + <param name="target">The span to check.</param> + <param name="change">The change to check.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.IsEndInsertion(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified change is at the end the span content and for insertion.</summary> + <returns>true if the specified change is at the end the span content and for insertion; otherwise, false.</returns> + <param name="target">The span to check.</param> + <param name="change">The change to check.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.IsEndReplace(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified change is at the end the span content and for replacement.</summary> + <returns>true if the specified change is at the end the span content and for replacement; otherwise, false.</returns> + <param name="target">The span to check.</param> + <param name="change">The change to check.</param> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.OwnsChange(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the span owns the specified change.</summary> + <returns>true if the span owns the specified change; otherwise, false.</returns> + <param name="target">The span to check.</param> + <param name="change">The change to check.</param> + </member> + <member name="P:System.Web.Razor.Editor.SpanEditHandler.Tokenizer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the method used to parse string into tokens. </summary> + <returns>The method used to parse string into tokens.</returns> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation of the span edit handler.</summary> + <returns>The string representation of the span edit handler.</returns> + </member> + <member name="M:System.Web.Razor.Editor.SpanEditHandler.UpdateSpan(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Updates the span using the normalized change.</summary> + <returns>The new span builder for the specified target.</returns> + <param name="target">The span to update.</param> + <param name="normalizedChange">The normalized change.</param> + </member> + <member name="T:System.Web.Razor.Generator.AddImportCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the added import code generator for the razor.</summary> + </member> + <member name="M:System.Web.Razor.Generator.AddImportCodeGenerator.#ctor(System.String,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.AddImportCodeGenerator" /> class.</summary> + <param name="ns">The string namespace.</param> + <param name="namespaceKeywordLength">The length of the keyword namespace.</param> + </member> + <member name="M:System.Web.Razor.Generator.AddImportCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether two object instances are equal.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare with the current object.</param> + </member> + <member name="M:System.Web.Razor.Generator.AddImportCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code with the specified parameters using the added import code generator.</summary> + <param name="target">The target span.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.AddImportCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.AddImportCodeGenerator.Namespace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the string namespace of the generator to add import code generator.</summary> + <returns>The string namespace of the generator to add import code generator.</returns> + </member> + <member name="P:System.Web.Razor.Generator.AddImportCodeGenerator.NamespaceKeywordLength"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the length of keyword namespace for the code generator.</summary> + <returns>The length of keyword namespace for the code generator.</returns> + </member> + <member name="M:System.Web.Razor.Generator.AddImportCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string that represents the current object.</summary> + <returns>A string that represents the current object.</returns> + </member> + <member name="T:System.Web.Razor.Generator.AttributeBlockCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the attributes of the block code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.AttributeBlockCodeGenerator.#ctor(System.String,System.Web.Razor.Text.LocationTagged{System.String},System.Web.Razor.Text.LocationTagged{System.String})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.AttributeBlockCodeGenerator" /> class.</summary> + <param name="name">The name.</param> + <param name="prefix">The prefix string.</param> + <param name="suffix">The suffix string.</param> + </member> + <member name="M:System.Web.Razor.Generator.AttributeBlockCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare with the current object.</param> + </member> + <member name="M:System.Web.Razor.Generator.AttributeBlockCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code to end the block using the specified parameters.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.AttributeBlockCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code to start the block using the specified parameters.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.AttributeBlockCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this code generator.</summary> + <returns>The hash code for this code generator.</returns> + </member> + <member name="P:System.Web.Razor.Generator.AttributeBlockCodeGenerator.Name"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the string name of the <see cref="T:System.Web.Razor.Generator.AttributeBlockCodeGenerator" />.</summary> + <returns>The string name of the <see cref="T:System.Web.Razor.Generator.AttributeBlockCodeGenerator" />.</returns> + </member> + <member name="P:System.Web.Razor.Generator.AttributeBlockCodeGenerator.Prefix"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the prefix of the code generator.</summary> + <returns>The prefix of the code generator.</returns> + </member> + <member name="P:System.Web.Razor.Generator.AttributeBlockCodeGenerator.Suffix"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the suffix for the code generator.</summary> + <returns>The suffix for the code generator.</returns> + </member> + <member name="M:System.Web.Razor.Generator.AttributeBlockCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string that represents the current object.</summary> + <returns>A string that represents the current object.</returns> + </member> + <member name="T:System.Web.Razor.Generator.BlockCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represent the block code generator for this razor syntax.</summary> + </member> + <member name="M:System.Web.Razor.Generator.BlockCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.BlockCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.BlockCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare with the current object.</param> + </member> + <member name="M:System.Web.Razor.Generator.BlockCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the end of the block code generator for this razor syntax.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.BlockCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the start of the block code generator for this razor syntax.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.BlockCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a hash code for the block code generator.</summary> + <returns>A hash code for the block code generator.</returns> + </member> + <member name="F:System.Web.Razor.Generator.BlockCodeGenerator.Null"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a null value for the block code generator.</summary> + </member> + <member name="T:System.Web.Razor.Generator.CodeGenerationCompleteEventArgs"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the completion of event arguments for the code generation.</summary> + </member> + <member name="M:System.Web.Razor.Generator.CodeGenerationCompleteEventArgs.#ctor(System.String,System.String,System.CodeDom.CodeCompileUnit)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.CodeGenerationCompleteEventArgs" /> class.</summary> + <param name="virtualPath">The virtual path string.</param> + <param name="physicalPath">The physical path string.</param> + <param name="generatedCode">The generated code compile unit.</param> + </member> + <member name="P:System.Web.Razor.Generator.CodeGenerationCompleteEventArgs.GeneratedCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the generated code to complete the event argument.</summary> + <returns>The generated code to complete the event argument.</returns> + </member> + <member name="P:System.Web.Razor.Generator.CodeGenerationCompleteEventArgs.PhysicalPath"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the physical path for the code generation.</summary> + <returns>The physical path for the code generation.</returns> + </member> + <member name="P:System.Web.Razor.Generator.CodeGenerationCompleteEventArgs.VirtualPath"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the virtual path of the code generation.</summary> + <returns>The virtual path of the code generation.</returns> + </member> + <member name="T:System.Web.Razor.Generator.CodeGeneratorContext"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents the context of the code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.AddCodeMapping(System.Web.Razor.Text.SourceLocation,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds a new generated code mapping to the collection.</summary> + <returns>The collection index of the newly added code mapping.</returns> + <param name="sourceLocation">The source location of the generated code mapping.</param> + <param name="generatedCodeStart">The code start of the generated code mapping.</param> + <param name="generatedCodeLength">The length of the generated code mapping.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.AddContextCall(System.Web.Razor.Parser.SyntaxTree.Span,System.String,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds a code statement for a context call on the specified method.</summary> + <param name="contentSpan">The content span.</param> + <param name="methodName">The name of the method to invoke a context call.</param> + <param name="isLiteral">true to specify that the method parameter is literal; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.AddDesignTimeHelperStatement(System.CodeDom.CodeSnippetStatement)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds a code statement that inserts the Razor design time helpers method in the specified code statement.</summary> + <param name="statement">The code statement that receives the code insertion.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.AddStatement(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds the specified code statement to the body of the target method.</summary> + <param name="generatedCode">The code statement to add the target method.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.AddStatement(System.String,System.CodeDom.CodeLinePragma)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds the specified code statement to the body of the target method.</summary> + <param name="body">The code statement to add the target method.</param> + <param name="pragma">The line pragma.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.BufferStatementFragment(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Appends the specified fragment to the current buffered statement.</summary> + <param name="fragment">The fragment to add.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.BufferStatementFragment(System.String,System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Appends the specified fragment to the current buffered statement.</summary> + <param name="fragment">The fragment to add.</param> + <param name="sourceSpan">The source span for the <paramref name="fragment" />.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.BufferStatementFragment(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Appends the content of the span to the current buffered statement.</summary> + <param name="sourceSpan">The source span whose content is to be added.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.ChangeStatementCollector(System.Action{System.String,System.CodeDom.CodeLinePragma})"> + <summary>Assigns a new statement collector and returns a disposable action that restores the old statement collector.</summary> + <returns>A disposable action that restores the old statement collector.</returns> + <param name="collector">The new statement collector.</param> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.CodeMappings"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the dictionary collection of generated code mapping.</summary> + <returns>The dictionary collection of generated code mapping.</returns> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.CompileUnit"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the code compile unit that will hold the program graph.</summary> + <returns>The code compile unit that will hold the program graph.</returns> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.Create(System.Web.Razor.RazorEngineHost,System.String,System.String,System.String,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a new instance of the <see cref="T:System.Web.Razor.Generator.CodeGeneratorContext" /> class.</summary> + <returns>The newly created instance of the code generator context.</returns> + <param name="host">The Razor engine host.</param> + <param name="className">The class name for the generated class type declaration.</param> + <param name="rootNamespace">The name for the generated namespace declaration.</param> + <param name="sourceFile">The source file.</param> + <param name="shouldGenerateLinePragmas">true to enable the generation of line pragmas; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.CurrentBufferedStatement"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the current buffered statement.</summary> + <returns>The current buffered statement.</returns> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.EnsureExpressionHelperVariable"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds the expression helper variable to the generated class if not yet added,</summary> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.FlushBufferedStatement"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Flushes the current buffered statement.</summary> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.GeneratedClass"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the generated class type declaration.</summary> + <returns>The generated class type declaration.</returns> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.GenerateLinePragma(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the line pragma for the specified source.</summary> + <returns>The line pragma for the specified source.</returns> + <param name="target">The source span.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.GenerateLinePragma(System.Web.Razor.Parser.SyntaxTree.Span,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the line pragma for the source.</summary> + <returns>The line pragma for the specified source.</returns> + <param name="target">The source span.</param> + <param name="generatedCodeStart">The start index of code.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.GenerateLinePragma(System.Web.Razor.Parser.SyntaxTree.Span,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the line pragma for the source.</summary> + <returns>The line pragma for the specified source.</returns> + <param name="target">The source span.</param> + <param name="generatedCodeStart">The start index of code.</param> + <param name="codeLength">The length of code.</param> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.GenerateLinePragma(System.Web.Razor.Text.SourceLocation,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the line pragma for the source.</summary> + <returns>The line pragma for the specified source.</returns> + <param name="start">The source location.</param> + <param name="generatedCodeStart">The start index of code.</param> + <param name="codeLength">The length of code.</param> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.Host"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the Razor engine host.</summary> + <returns>The Razor engine host.</returns> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.MarkEndOfGeneratedCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Marks the end of generated code.</summary> + </member> + <member name="M:System.Web.Razor.Generator.CodeGeneratorContext.MarkStartOfGeneratedCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Marks the start of generated code.</summary> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.Namespace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the generated namespace declaration.</summary> + <returns>The generated namespace declaration.</returns> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.SourceFile"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the source file.</summary> + <returns>The source file.</returns> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.TargetMethod"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the generated member method.</summary> + <returns>The generated member method.</returns> + </member> + <member name="P:System.Web.Razor.Generator.CodeGeneratorContext.TargetWriterName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the name of text writer.</summary> + <returns>The name of text writer.</returns> + </member> + <member name="T:System.Web.Razor.Generator.CSharpRazorCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a Razor code generator for C# language.</summary> + </member> + <member name="M:System.Web.Razor.Generator.CSharpRazorCodeGenerator.#ctor(System.String,System.String,System.String,System.Web.Razor.RazorEngineHost)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.CSharpRazorCodeGenerator" /> class.</summary> + <param name="className">The class name for the generated class type declaration.</param> + <param name="rootNamespaceName">The name for the generated namespace declaration.</param> + <param name="sourceFileName">The source file.</param> + <param name="host">The Razor engine host.</param> + </member> + <member name="M:System.Web.Razor.Generator.CSharpRazorCodeGenerator.Initialize(System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes the context for this code generator.</summary> + <param name="context">The context for this code generator.</param> + </member> + <member name="T:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the dynamic attributes of the block code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.#ctor(System.Web.Razor.Text.LocationTagged{System.String},System.Int32,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instances of the <see cref="T:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator" /> class.</summary> + <param name="prefix">The prefix.</param> + <param name="offset">The offset values.</param> + <param name="line">The line values.</param> + <param name="col">The col.</param> + </member> + <member name="M:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.#ctor(System.Web.Razor.Text.LocationTagged{System.String},System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instances of the <see cref="T:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator" /> class.</summary> + <param name="prefix">The string prefix.</param> + <param name="valueStart">The value start.</param> + </member> + <member name="M:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare with the current object.</param> + </member> + <member name="M:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code to end the block using the specified parameters.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code to start the block using the specified parameters.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.Prefix"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the namespace prefix of the code generator.</summary> + <returns>The namespace prefix of the code generator.</returns> + </member> + <member name="M:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string that represents the current object.</summary> + <returns>A string that represents the current object.</returns> + </member> + <member name="P:System.Web.Razor.Generator.DynamicAttributeBlockCodeGenerator.ValueStart"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the value start for the dynamic attribute block code generator.</summary> + <returns>The value start for the dynamic attribute block code generator.</returns> + </member> + <member name="T:System.Web.Razor.Generator.ExpressionCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a code generator for expression.</summary> + </member> + <member name="M:System.Web.Razor.Generator.ExpressionCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.ExpressionCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.ExpressionCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates whether this instance and a specified object are equal.</summary> + <returns>true if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, false.</returns> + <param name="obj">The object to compare with the current instance.</param> + </member> + <member name="M:System.Web.Razor.Generator.ExpressionCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code for the expression.</summary> + <param name="target">The source span whose content represents an expression.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.ExpressionCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the end code for the block.</summary> + <param name="target">The target block for the end code generation.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.ExpressionCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the start code for the block.</summary> + <param name="target">The target block the start code generation.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.ExpressionCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="M:System.Web.Razor.Generator.ExpressionCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the string representation of this instance.</summary> + <returns>The string representation of this instance.</returns> + </member> + <member name="T:System.Web.Razor.Generator.ExpressionRenderingMode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Generator.ExpressionRenderingMode.InjectCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Generator.ExpressionRenderingMode.WriteToOutput"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Generator.GeneratedClassContext"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a generated class context.</summary> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.#ctor(System.String,System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> class.</summary> + <param name="executeMethodName">The execute method name.</param> + <param name="writeMethodName">The write method name.</param> + <param name="writeLiteralMethodName">Write literal method name.</param> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.#ctor(System.String,System.String,System.String,System.String,System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> class.</summary> + <param name="executeMethodName">Execute method name.</param> + <param name="writeMethodName">Write method name.</param> + <param name="writeLiteralMethodName">Write literal method name.</param> + <param name="writeToMethodName">Write to method name.</param> + <param name="writeLiteralToMethodName">Write literal to method name.</param> + <param name="templateTypeName">Template type name.</param> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.#ctor(System.String,System.String,System.String,System.String,System.String,System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> class.</summary> + <param name="executeMethodName">Execute method name.</param> + <param name="writeMethodName">Write method name.</param> + <param name="writeLiteralMethodName">Write literal method name.</param> + <param name="writeToMethodName">Write to method name.</param> + <param name="writeLiteralToMethodName">Write literal to method name.</param> + <param name="templateTypeName">Template type name.</param> + <param name="defineSectionMethodName">Define section method name.</param> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.#ctor(System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> class.</summary> + <param name="executeMethodName">Execute method name.</param> + <param name="writeMethodName">Write method name.</param> + <param name="writeLiteralMethodName">Write literal method name.</param> + <param name="writeToMethodName">Write to method name.</param> + <param name="writeLiteralToMethodName">Write literal to method name.</param> + <param name="templateTypeName">Template type name.</param> + <param name="defineSectionMethodName">Define section method name.</param> + <param name="beginContextMethodName">Begin context method name.</param> + <param name="endContextMethodName">End context method name.</param> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.AllowSections"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value indicating whether the context allows sections.</summary> + <returns>true if the context allows sections; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.AllowTemplates"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value indicating whether the context allows templates.</summary> + <returns>true if the context allows templates; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.BeginContextMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method before the generated context.</summary> + <returns>The name of the method before the generated context.</returns> + </member> + <member name="F:System.Web.Razor.Generator.GeneratedClassContext.Default"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Defines the default generated context.</summary> + </member> + <member name="F:System.Web.Razor.Generator.GeneratedClassContext.DefaultExecuteMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Defines the default name of the execute method.</summary> + </member> + <member name="F:System.Web.Razor.Generator.GeneratedClassContext.DefaultLayoutPropertyName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Defines the default name of the layout property.</summary> + </member> + <member name="F:System.Web.Razor.Generator.GeneratedClassContext.DefaultWriteAttributeMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Defines the default name of the write attribute method.</summary> + </member> + <member name="F:System.Web.Razor.Generator.GeneratedClassContext.DefaultWriteAttributeToMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Defines the default name of the write to attribute to method.</summary> + </member> + <member name="F:System.Web.Razor.Generator.GeneratedClassContext.DefaultWriteLiteralMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Specifies the default name of the write literal method.</summary> + </member> + <member name="F:System.Web.Razor.Generator.GeneratedClassContext.DefaultWriteMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Specifies the default name of the write method.</summary> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.DefineSectionMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method that defines the section of the context.</summary> + <returns>The name of the method that defines the section of the context.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.EndContextMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method after the generated context.</summary> + <returns>The name of the method after the generated context.</returns> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.ExecuteMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method that will be invoked on the context.</summary> + <returns>The name of the method that will be invoked on the context.</returns> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this current instance.</summary> + <returns>The hash code for this current instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.LayoutPropertyName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the property name for the layout.</summary> + <returns>The property name for the layout.</returns> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.op_Equality(System.Web.Razor.Generator.GeneratedClassContext,System.Web.Razor.Generator.GeneratedClassContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> object are equal.</summary> + <returns>true if the two <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> object are equal; otherwise, false.</returns> + <param name="left">The first object to compare.</param> + <param name="right">The second object to compare.</param> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedClassContext.op_Inequality(System.Web.Razor.Generator.GeneratedClassContext,System.Web.Razor.Generator.GeneratedClassContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> object are not equal.</summary> + <returns>true if the two <see cref="T:System.Web.Razor.Generator.GeneratedClassContext" /> object are not equal; otherwise, false.</returns> + <param name="left">The first object to compare.</param> + <param name="right">The second object to compare.</param> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.ResolveUrlMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method that resolves a Url for the context.</summary> + <returns>The name of the method that resolves a Url for the context.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.SupportsInstrumentation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value indicating whether the generated class supports instrumentation.</summary> + <returns>true if the generated class supports instrumentation; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.TemplateTypeName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the type name for the template.</summary> + <returns>The type name for the template.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.WriteAttributeMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method that writes an attribute.</summary> + <returns>The name of the method that writes an attribute.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.WriteAttributeToMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method where to write an attribute.</summary> + <returns>The name of the method where to write an attribute.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.WriteLiteralMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method where to write literal for the context.</summary> + <returns>The name of the method where to write literal for the context.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.WriteLiteralToMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method where to write literal for the context.</summary> + <returns>The name of the method where to write literal for the context.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.WriteMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method that will write on the context.</summary> + <returns>The name of the method that will write on the context.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedClassContext.WriteToMethodName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the method that will write on the context.</summary> + <returns>The name of the method that will write on the context.</returns> + </member> + <member name="T:System.Web.Razor.Generator.GeneratedCodeMapping"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the generated code mapping objects.</summary> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedCodeMapping.#ctor(System.Int32,System.Int32,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.GeneratedCodeMapping" /> class.</summary> + <param name="startLine">The starting line.</param> + <param name="startColumn">The starting column.</param> + <param name="startGeneratedColumn">The start generated column.</param> + <param name="codeLength">The code length.</param> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedCodeMapping.#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.GeneratedCodeMapping" /> class.</summary> + <param name="startOffset">The start offset.</param> + <param name="startLine">The starting line.</param> + <param name="startColumn">The starting column.</param> + <param name="startGeneratedColumn">The start generated column.</param> + <param name="codeLength">The code length.</param> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedCodeMapping.CodeLength"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the length of the generated map codes.</summary> + <returns>The length of the generated map codes.</returns> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedCodeMapping.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current generated code mapping object.</summary> + <returns>true if the specified object is equal to the current generated code mapping object; otherwise, false.</returns> + <param name="obj">The object to compare with the current object.</param> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedCodeMapping.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for the generated code mapping object.</summary> + <returns>The hash code for the generated code mapping object.</returns> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedCodeMapping.op_Equality(System.Web.Razor.Generator.GeneratedCodeMapping,System.Web.Razor.Generator.GeneratedCodeMapping)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two specified generated code mapping objects have the same value.</summary> + <returns>true if the two specified generated code mapping objects have the same value; otherwise, false.</returns> + <param name="left">The left generated code mapping objects.</param> + <param name="right">The right generated code mapping objects.</param> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedCodeMapping.op_Inequality(System.Web.Razor.Generator.GeneratedCodeMapping,System.Web.Razor.Generator.GeneratedCodeMapping)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two specified generated code mapping objects have different values.</summary> + <returns>true the two specified generated code mapping objects have different values; otherwise, false.</returns> + <param name="right">The right generated code mapping objects.</param> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedCodeMapping.StartColumn"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the starting column of the generated code maps.</summary> + <returns>The starting column of the generated code maps.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedCodeMapping.StartGeneratedColumn"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the starting column of a generated code maps in the generated source file.</summary> + <returns>The starting column of a generated code maps in the generated source file.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedCodeMapping.StartLine"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the starting line of the generated code maps.</summary> + <returns>The starting line of the generated code maps.</returns> + </member> + <member name="P:System.Web.Razor.Generator.GeneratedCodeMapping.StartOffset"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the starting offset of the generated code maps.</summary> + <returns>The starting offset of the generated code maps.</returns> + </member> + <member name="M:System.Web.Razor.Generator.GeneratedCodeMapping.ToString"> + <summary>Returns a string that represents the current object.</summary> + <returns>A string that represents the current object.</returns> + </member> + <member name="T:System.Web.Razor.Generator.HelperCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a helper code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.HelperCodeGenerator.#ctor(System.Web.Razor.Text.LocationTagged{System.String},System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.HelperCodeGenerator" /> class.</summary> + <param name="signature">The signature.</param> + <param name="headerComplete">true to complete the header; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Generator.HelperCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="P:System.Web.Razor.Generator.HelperCodeGenerator.Footer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the footer for this code.</summary> + <returns>The footer for this code.</returns> + </member> + <member name="M:System.Web.Razor.Generator.HelperCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a block after the code.</summary> + <param name="target">The block to generate.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.HelperCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a block before the code.</summary> + <param name="target">The block to generate.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.HelperCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the hash code for the current instance.</summary> + <returns>The hash code for the current instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.HelperCodeGenerator.HeaderComplete"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value indicating whether the header for this code is complete.</summary> + <returns>true if the header for this code is complete; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Generator.HelperCodeGenerator.Signature"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the signature for this code.</summary> + <returns>The signature for this code.</returns> + </member> + <member name="M:System.Web.Razor.Generator.HelperCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of the current instance.</summary> + <returns>A string representation of the current instance.</returns> + </member> + <member name="T:System.Web.Razor.Generator.HybridCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a hybrid code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.HybridCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.HybridCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.HybridCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code for the data model from switches identified by parameters.</summary> + <param name="target">The target object.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.HybridCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates an end block code.</summary> + <param name="target">The target object.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.HybridCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the start block code.</summary> + <param name="target">The target object.</param> + <param name="context">The code generator context.</param> + </member> + <member name="T:System.Web.Razor.Generator.IBlockCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the <see cref="T:System.Web.Razor.Generator.IBlockCodeGenerator" /> for the webpages.</summary> + </member> + <member name="M:System.Web.Razor.Generator.IBlockCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the end block code for the razor.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.IBlockCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the start block code for the razor.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="T:System.Web.Razor.Generator.ISpanCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a phase of the code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.ISpanCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code for the data model with the specified target and context.</summary> + <param name="target">The target object.</param> + <param name="context">The code generator context.</param> + </member> + <member name="T:System.Web.Razor.Generator.LiteralAttributeCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a code generator for literal attribute.</summary> + </member> + <member name="M:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.#ctor(System.Web.Razor.Text.LocationTagged{System.String},System.Web.Razor.Text.LocationTagged{System.String})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. . Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.LiteralAttributeCodeGenerator" /> class.</summary> + <param name="prefix">The prefix of the literal attribute.</param> + <param name="value">The value of the literal attribute.</param> + </member> + <member name="M:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.#ctor(System.Web.Razor.Text.LocationTagged{System.String},System.Web.Razor.Text.LocationTagged{System.Web.Razor.Generator.SpanCodeGenerator})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. . Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.LiteralAttributeCodeGenerator" /> class.</summary> + <param name="prefix">The prefix of the literal attribute.</param> + <param name="valueGenerator">The value generator for the literal attribute.</param> + </member> + <member name="M:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this instance.</summary> + <returns>true if the specified object is equal to this instance; otherwise, false.</returns> + <param name="obj">The object to compare to this instance.</param> + </member> + <member name="M:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the code for the literal attribute.</summary> + <param name="target">The source span whose content represents the literal attribute.</param> + <param name="context">The context of the code generator.</param> + </member> + <member name="M:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the hash code for the current instance.</summary> + <returns>The hash code for the current instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.Prefix"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the prefix of the literal attribute.</summary> + <returns>The prefix of the literal attribute.</returns> + </member> + <member name="M:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation of this instance.</summary> + <returns>The string representation of this instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.Value"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the value of the literal attribute.</summary> + <returns>The value of the literal attribute.</returns> + </member> + <member name="P:System.Web.Razor.Generator.LiteralAttributeCodeGenerator.ValueGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the value generator for the literal attribute.</summary> + <returns>The value generator for the literal attribute.</returns> + </member> + <member name="T:System.Web.Razor.Generator.MarkupCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a code generator for markup.</summary> + </member> + <member name="M:System.Web.Razor.Generator.MarkupCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.MarkupCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.MarkupCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this instance.</summary> + <returns>true if the specified object is equal to this instance; otherwise, false.</returns> + <param name="obj">The object to compare to this instance.</param> + </member> + <member name="M:System.Web.Razor.Generator.MarkupCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the code for the markup.</summary> + <param name="target">The source span whose content represents the markup.</param> + <param name="context">The context of the code generator.</param> + </member> + <member name="M:System.Web.Razor.Generator.MarkupCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="M:System.Web.Razor.Generator.MarkupCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation for this instance.</summary> + <returns>The string representation for this instance.</returns> + </member> + <member name="T:System.Web.Razor.Generator.RazorCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a Razor code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.RazorCodeGenerator.#ctor(System.String,System.String,System.String,System.Web.Razor.RazorEngineHost)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.RazorCodeGenerator" /> class.</summary> + <param name="className">The class name.</param> + <param name="rootNamespaceName">The root namespace name.</param> + <param name="sourceFileName">The source file name.</param> + <param name="host">The host.</param> + </member> + <member name="P:System.Web.Razor.Generator.RazorCodeGenerator.ClassName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the class name for this code.</summary> + <returns>The class name for this code.</returns> + </member> + <member name="P:System.Web.Razor.Generator.RazorCodeGenerator.Context"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the context of this code generator.</summary> + <returns>The context of this code generator.</returns> + </member> + <member name="P:System.Web.Razor.Generator.RazorCodeGenerator.DesignTimeMode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value indicating whether the code generator is in design-time mode.</summary> + <returns>true if the code generator is in design-time mode; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Generator.RazorCodeGenerator.GenerateLinePragmas"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value indicating whether the generator should generate line pragmas in the Razor code.</summary> + <returns>true if the generator should generate line pragmas in the Razor code; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Generator.RazorCodeGenerator.Host"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the razor engine host.</summary> + <returns>The razor engine host.</returns> + </member> + <member name="M:System.Web.Razor.Generator.RazorCodeGenerator.Initialize(System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes the current <see cref="T:System.Web.Razor.Generator.RazorCodeGenerator" /> instance.</summary> + <param name="context">The context.</param> + </member> + <member name="M:System.Web.Razor.Generator.RazorCodeGenerator.OnComplete"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Raises the Complete event.</summary> + </member> + <member name="P:System.Web.Razor.Generator.RazorCodeGenerator.RootNamespaceName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the root namespace.</summary> + <returns>The name of the root namespace.</returns> + </member> + <member name="P:System.Web.Razor.Generator.RazorCodeGenerator.SourceFileName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the source file.</summary> + <returns>The name of the source file.</returns> + </member> + <member name="M:System.Web.Razor.Generator.RazorCodeGenerator.VisitEndBlock(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the end block.</summary> + <param name="block">The block to visit.</param> + </member> + <member name="M:System.Web.Razor.Generator.RazorCodeGenerator.VisitSpan(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the span.</summary> + <param name="span">The span to visit.</param> + </member> + <member name="M:System.Web.Razor.Generator.RazorCodeGenerator.VisitStartBlock(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the start block.</summary> + <param name="block">The block to visit.</param> + </member> + <member name="T:System.Web.Razor.Generator.RazorCommentCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the razor comment code generator for the webpages.</summary> + </member> + <member name="M:System.Web.Razor.Generator.RazorCommentCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.RazorCommentCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.RazorCommentCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates the start block code with the specified parameters.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="T:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a code generator for Razor directive attribute. </summary> + </member> + <member name="M:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator.#ctor(System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator" /> class.</summary> + <param name="name">The name of the directive attribute.</param> + <param name="value">The value of the directive attribute.</param> + </member> + <member name="M:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this instance.</summary> + <returns>true if the specified object is equal to this instance; otherwise, false.</returns> + <param name="obj">The object to compare to this instance.</param> + </member> + <member name="M:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the code for the directive attribute.</summary> + <param name="target">The source span whose content represents the directive attribute to generate.</param> + <param name="context">The context of the code generator.</param> + </member> + <member name="M:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator.Name"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the name of the directive attribute.</summary> + <returns>The name of the directive attribute.</returns> + </member> + <member name="M:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation for this instance.</summary> + <returns>The string representation for this instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.RazorDirectiveAttributeCodeGenerator.Value"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the value of the directive attribute.</summary> + <returns>The value of the directive attribute.</returns> + </member> + <member name="T:System.Web.Razor.Generator.ResolveUrlCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the resolve Url code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.ResolveUrlCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.ResolveUrlCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.ResolveUrlCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates whether this instance and a specified object are equal.</summary> + <returns>true if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, false.</returns> + <param name="obj">The object to compare with the current instance.</param> + </member> + <member name="M:System.Web.Razor.Generator.ResolveUrlCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code for the Url.</summary> + <param name="target">The target object.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.ResolveUrlCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="M:System.Web.Razor.Generator.ResolveUrlCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the fully qualified type name of this instance.</summary> + <returns>The fully qualified type name.</returns> + </member> + <member name="T:System.Web.Razor.Generator.SectionCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a section code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SectionCodeGenerator.#ctor(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.SectionCodeGenerator" /> class.</summary> + <param name="sectionName">The name of the section code.</param> + </member> + <member name="M:System.Web.Razor.Generator.SectionCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Generator.SectionCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a block after the section code.</summary> + <param name="target">The target to generate.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.SectionCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a block before the section code.</summary> + <param name="target">The target to generate.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.SectionCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Retrieves the hash code for this current instance.</summary> + <returns>The hash code for this current instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.SectionCodeGenerator.SectionName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the name of the section.</summary> + <returns>The name of the section.</returns> + </member> + <member name="M:System.Web.Razor.Generator.SectionCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of this current instance.</summary> + <returns>A string representation of this current instance.</returns> + </member> + <member name="T:System.Web.Razor.Generator.SetBaseTypeCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a code generator for set base type.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SetBaseTypeCodeGenerator.#ctor(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.SetBaseTypeCodeGenerator" /> class.</summary> + <param name="baseType">The set base type.</param> + </member> + <member name="P:System.Web.Razor.Generator.SetBaseTypeCodeGenerator.BaseType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the set base type.</summary> + <returns>The set base type.</returns> + </member> + <member name="M:System.Web.Razor.Generator.SetBaseTypeCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this instance.</summary> + <returns>true if the specified object is equal to this instance; otherwise, false.</returns> + <param name="obj">The object to compare to this instance.</param> + </member> + <member name="M:System.Web.Razor.Generator.SetBaseTypeCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the code for this set base type.</summary> + <param name="target">The source span that contains the set base type to generate code.</param> + <param name="context">The context of the code generator.</param> + </member> + <member name="M:System.Web.Razor.Generator.SetBaseTypeCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the hash code for this current instance.</summary> + <returns>The hash code for this current instance.</returns> + </member> + <member name="M:System.Web.Razor.Generator.SetBaseTypeCodeGenerator.ResolveType(System.Web.Razor.Generator.CodeGeneratorContext,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Resolves the given set base type.</summary> + <returns>The resolved set base type.</returns> + <param name="context">The context of the code generator.</param> + <param name="baseType">The set base type to resolve.</param> + </member> + <member name="M:System.Web.Razor.Generator.SetBaseTypeCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation for this instance.</summary> + <returns>The string representation for this instance.</returns> + </member> + <member name="T:System.Web.Razor.Generator.SetLayoutCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a code generator that sets layout for the web Razor.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SetLayoutCodeGenerator.#ctor(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.SetLayoutCodeGenerator" /> class.</summary> + <param name="layoutPath">The layout path.</param> + </member> + <member name="M:System.Web.Razor.Generator.SetLayoutCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Generator.SetLayoutCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a layout code.</summary> + <param name="target">The target where to generate the code.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.SetLayoutCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Retrieves a hash code for this current instance.</summary> + <returns>A hash code for this current instance.</returns> + </member> + <member name="P:System.Web.Razor.Generator.SetLayoutCodeGenerator.LayoutPath"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the path of the layout code.</summary> + <returns>The path of the layout code.</returns> + </member> + <member name="M:System.Web.Razor.Generator.SetLayoutCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of this current instance.</summary> + <returns>A string representation of this current instance.</returns> + </member> + <member name="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the conversion of the SetVBOptionCodeGenerator of the value.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SetVBOptionCodeGenerator.#ctor(System.String,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> class.</summary> + <param name="optionName">The option name.</param> + <param name="value">true if the object has a value; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Generator.SetVBOptionCodeGenerator.Explicit(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Converts the <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> explicitly to the on and off value.</summary> + <returns>The <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> explicitly converts to the on and off value.</returns> + <param name="onOffValue">true if the <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> converts to on and off value; otherwise, false.</param> + </member> + <member name="F:System.Web.Razor.Generator.SetVBOptionCodeGenerator.ExplicitCodeDomOptionName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the explicit code Dom option name.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SetVBOptionCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code for the specified parameters.</summary> + <param name="target">The target.</param> + <param name="context">The code generator context.</param> + </member> + <member name="P:System.Web.Razor.Generator.SetVBOptionCodeGenerator.OptionName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the option name for the code generator.</summary> + <returns>The option name for the code generator.</returns> + </member> + <member name="M:System.Web.Razor.Generator.SetVBOptionCodeGenerator.Strict(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Strictly converts the <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> to the on and off value.</summary> + <returns>The <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> strictly converts to the on and off value.</returns> + <param name="onOffValue">true if the <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> strictly converts to the on and off value; otherwise, false.</param> + </member> + <member name="F:System.Web.Razor.Generator.SetVBOptionCodeGenerator.StrictCodeDomOptionName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the strict code Dom option name.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SetVBOptionCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a String that represents the current Object.</summary> + <returns>A String that represents the current Object.</returns> + </member> + <member name="P:System.Web.Razor.Generator.SetVBOptionCodeGenerator.Value"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether the <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> has a value.</summary> + <returns>true if the <see cref="T:System.Web.Razor.Generator.SetVBOptionCodeGenerator" /> has a value; otherwise, false.</returns> + </member> + <member name="T:System.Web.Razor.Generator.SpanCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the span code generator for the razor.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SpanCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.SpanCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.SpanCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare with the current object.</param> + </member> + <member name="M:System.Web.Razor.Generator.SpanCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a code for the specified target and context parameters.</summary> + <param name="target">The target span.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.SpanCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a hash code for the span code generator.</summary> + <returns>A hash code for the span code generator.</returns> + </member> + <member name="F:System.Web.Razor.Generator.SpanCodeGenerator.Null"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a null value for the span code generator.</summary> + </member> + <member name="T:System.Web.Razor.Generator.StatementCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a code generator for the statement.</summary> + </member> + <member name="M:System.Web.Razor.Generator.StatementCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.StatementCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.StatementCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this instance.</summary> + <returns>true if the specified object is equal to this instance; otherwise, false.</returns> + <param name="obj">The object to compare to this instance.</param> + </member> + <member name="M:System.Web.Razor.Generator.StatementCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Generates the code for the statement.</summary> + <param name="target">The span source whose content contains the statement to generate.</param> + <param name="context">The context of the code generator.</param> + </member> + <member name="M:System.Web.Razor.Generator.StatementCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the hash code for this current instance.</summary> + <returns>The hash code for this current instance.</returns> + </member> + <member name="M:System.Web.Razor.Generator.StatementCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation for this instance.</summary> + <returns>The string representation for this instance.</returns> + </member> + <member name="T:System.Web.Razor.Generator.TemplateBlockCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the template block code generator of the razor.</summary> + </member> + <member name="M:System.Web.Razor.Generator.TemplateBlockCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.TemplateBlockCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.TemplateBlockCodeGenerator.GenerateEndBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code to end the block of the template block code generator.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.TemplateBlockCodeGenerator.GenerateStartBlockCode(System.Web.Razor.Parser.SyntaxTree.Block,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code to start the block for the template block code generator.</summary> + <param name="target">The target block.</param> + <param name="context">The code generator context.</param> + </member> + <member name="T:System.Web.Razor.Generator.TypeMemberCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a type member code generator.</summary> + </member> + <member name="M:System.Web.Razor.Generator.TypeMemberCodeGenerator.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.TypeMemberCodeGenerator" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Generator.TypeMemberCodeGenerator.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Generator.TypeMemberCodeGenerator.GenerateCode(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Generator.CodeGeneratorContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates code with a given target and context.</summary> + <param name="target">The target where to generate the code.</param> + <param name="context">The code generator context.</param> + </member> + <member name="M:System.Web.Razor.Generator.TypeMemberCodeGenerator.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Retrieves the hash code for this current instance.</summary> + <returns>The hash code for this current instance.</returns> + </member> + <member name="M:System.Web.Razor.Generator.TypeMemberCodeGenerator.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of this code.</summary> + <returns>A string representation of this code.</returns> + </member> + <member name="T:System.Web.Razor.Generator.VBRazorCodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the razor code generator for VB.</summary> + </member> + <member name="M:System.Web.Razor.Generator.VBRazorCodeGenerator.#ctor(System.String,System.String,System.String,System.Web.Razor.RazorEngineHost)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Generator.VBRazorCodeGenerator" /> class.</summary> + <param name="className">The name of the class.</param> + <param name="rootNamespaceName">The root namespace.</param> + <param name="sourceFileName">The file name of the asset source.</param> + <param name="host">The host.</param> + </member> + <member name="T:System.Web.Razor.Parser.BalancingModes"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.BalancingModes.AllowCommentsAndTemplates"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.BalancingModes.AllowEmbeddedTransitions"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.BalancingModes.BacktrackOnFailure"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.BalancingModes.NoErrorOnFailure"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.BalancingModes.None"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Parser.CallbackVisitor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a visitor that executes a callback upon the completion of a visit.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.#ctor(System.Action{System.Web.Razor.Parser.SyntaxTree.Span})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.CallbackVisitor" /> class.</summary> + <param name="spanCallback">The delegate for the span visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.#ctor(System.Action{System.Web.Razor.Parser.SyntaxTree.Span},System.Action{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.CallbackVisitor" /> class.</summary> + <param name="spanCallback">The delegate for the span visit.</param> + <param name="errorCallback">The delegate for the error visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.#ctor(System.Action{System.Web.Razor.Parser.SyntaxTree.Span},System.Action{System.Web.Razor.Parser.SyntaxTree.RazorError},System.Action{System.Web.Razor.Parser.SyntaxTree.BlockType},System.Action{System.Web.Razor.Parser.SyntaxTree.BlockType})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.CallbackVisitor" /> class.</summary> + <param name="spanCallback">The delegate for the span visit.</param> + <param name="errorCallback">The delegate for the error visit.</param> + <param name="startBlockCallback">The delegate for the start block visit.</param> + <param name="endBlockCallback">The delegate for the end block visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.#ctor(System.Action{System.Web.Razor.Parser.SyntaxTree.Span},System.Action{System.Web.Razor.Parser.SyntaxTree.RazorError},System.Action{System.Web.Razor.Parser.SyntaxTree.BlockType},System.Action{System.Web.Razor.Parser.SyntaxTree.BlockType},System.Action)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.CallbackVisitor" /> class.</summary> + <param name="spanCallback">The delegate for the span visit.</param> + <param name="errorCallback">The delegate for the error visit.</param> + <param name="startBlockCallback">The delegate for the start block visit.</param> + <param name="endBlockCallback">The delegate for the end block visit.</param> + <param name="completeCallback">The delegate to execute for the complete event.</param> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.OnComplete"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. </summary> + </member> + <member name="P:System.Web.Razor.Parser.CallbackVisitor.SynchronizationContext"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the synchronization context for this callback visitor.</summary> + <returns>The synchronization context for this callback visitor.</returns> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.VisitEndBlock(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Executes the visitor callback to visit the end block.</summary> + <param name="block">The end block to visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.VisitError(System.Web.Razor.Parser.SyntaxTree.RazorError)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Executes the visitor callback to visit the error.</summary> + <param name="err">The Razor error to visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.VisitSpan(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Executes the visitor callback to visit the span.</summary> + <param name="span">The span to visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.CallbackVisitor.VisitStartBlock(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Executes the visitor callback to visit the start block.</summary> + <param name="block">The start block to visit.</param> + </member> + <member name="T:System.Web.Razor.Parser.CSharpCodeParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a C sharp code parser.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.CSharpCodeParser" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.AcceptIf(System.Web.Razor.Tokenizer.Symbols.CSharpKeyword)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parser accepts the ‘IF’ keyword.</summary> + <returns>true if the parser accepts the ‘IF’ keyword; otherwise, false.</returns> + <param name="keyword">The keyword to accept.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.AssertDirective(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Asserts a directive code.</summary> + <param name="directive">The directive code to assert.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.At(System.Web.Razor.Tokenizer.Symbols.CSharpKeyword)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code contains ‘AT’ keyword.</summary> + <returns>true if the code contains ‘AT’ keyword; otherwise, false.</returns> + <param name="keyword">The keyword.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.BaseTypeDirective(System.String,System.Func{System.String,System.Web.Razor.Generator.SpanCodeGenerator})"> + <summary>Indicates the base type directive.</summary> + <param name="noTypeNameError">The no type name error.</param> + <param name="createCodeGenerator">The create code generator.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.FunctionsDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the functions directive.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.HandleEmbeddedTransition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the code that handles embedded transition.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.HelperDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a helper directive.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.InheritsDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates which class the application will derive the view from, and can therefore ensure proper type checking.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.InheritsDirectiveCore"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Inherits a directive core.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.IsAtEmbeddedTransition(System.Boolean,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code is at embedded transition.</summary> + <returns>true if the code is at embedded transition; otherwise, false.</returns> + <param name="allowTemplatesAndComments">true to allow templates and comments; otherwise, false.</param> + <param name="allowTransitions">true to allow transitions; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Parser.CSharpCodeParser.IsNested"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value that indicates whether the code is nested.</summary> + <returns>true if the code is nested; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.IsSpacingToken(System.Boolean,System.Boolean)"> + <summary>Indicates whether the lines and comments is spacing token.</summary> + <returns>The function that indicates the spacing token.</returns> + <param name="includeNewLines">true to include new lines; otherwise, false.</param> + <param name="includeComments">true to include comments; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Parser.CSharpCodeParser.Keywords"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the C sharp language keywords.</summary> + <returns>The C sharp language keywords.</returns> + </member> + <member name="P:System.Web.Razor.Parser.CSharpCodeParser.Language"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the specific language for parsing.</summary> + <returns>The specific language for parsing.</returns> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.LayoutDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the layout directive.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.MapDirectives(System.Action,System.String[])"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Maps the given directives.</summary> + <param name="handler">The handler.</param> + <param name="directives">The directives.</param> + </member> + <member name="P:System.Web.Razor.Parser.CSharpCodeParser.OtherParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the other parser used for the code.</summary> + <returns>The other parser used for the code.</returns> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.OutputSpanBeforeRazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Spans the output of the parsing before the comment.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.ParseBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Blocks the parsing.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.ReservedDirective(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the reserved directive.</summary> + <param name="topLevel">Determines whether the directive is a top level.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.SectionDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a section directive.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.SessionStateDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a session state directive.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.SessionStateDirectiveCore"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the session state directive core.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.SessionStateTypeDirective(System.String,System.Func{System.String,System.String,System.Web.Razor.Generator.SpanCodeGenerator})"> + <summary>Indicates the directive for session state type.</summary> + <param name="noValueError">The no value error.</param> + <param name="createCodeGenerator">The create code generator.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.TryGetDirectiveHandler(System.String,System.Action@)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a directive handler.</summary> + <returns>true if successful; otherwise, false.</returns> + <param name="directive">The directive.</param> + <param name="handler">The handler.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.ValidSessionStateValue"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the value of the session state is valid.</summary> + <returns>true if the value of the session state is valid; otherwise, false.</returns> + </member> + <member name="T:System.Web.Razor.Parser.CSharpCodeParser.Block"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the block for this CSharpCode parser.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.Block.#ctor(System.String,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.CSharpCodeParser.Block" /> class.</summary> + <param name="name">The string name.</param> + <param name="start">The start of the source location.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpCodeParser.Block.#ctor(System.Web.Razor.Tokenizer.Symbols.CSharpSymbol)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.CSharpCodeParser.Block" /> class.</summary> + <param name="symbol">The CSharp symbol.</param> + </member> + <member name="P:System.Web.Razor.Parser.CSharpCodeParser.Block.Name"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the string name for the block.</summary> + <returns>The string name for the block.</returns> + </member> + <member name="P:System.Web.Razor.Parser.CSharpCodeParser.Block.Start"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the source location to start the block.</summary> + <returns>The source location to start the block.</returns> + </member> + <member name="T:System.Web.Razor.Parser.CSharpLanguageCharacteristics"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the different language characteristics in a CSharp language.</summary> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.CreateMarkerSymbol(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a marker symbol in the code.</summary> + <returns>A marker symbol in the code.</returns> + <param name="location">The source location.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a symbol in the code.</summary> + <returns>A symbol in the code.</returns> + <param name="location">The source location.</param> + <param name="content">The content value.</param> + <param name="type">The html symbol type.</param> + <param name="errors">List of errors.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.CreateTokenizer(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a language tokenizer.</summary> + <returns>A language tokenizer.</returns> + <param name="source">The source of the text document.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.FlipBracket(System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Flips the bracket symbol in the code.</summary> + <returns>The bracket symbol in the code.</returns> + <param name="bracket">The symbol bracket.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.GetKeyword(System.Web.Razor.Tokenizer.Symbols.CSharpKeyword)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the keyword in the code.</summary> + <returns>The keyword in the code.</returns> + <param name="keyword">The keyword.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.GetKnownSymbolType(System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the <see cref="T:System.Web.Razor.Parser.CSharpLanguageCharacteristics" /> in the code.</summary> + <returns>The <see cref="T:System.Web.Razor.Parser.CSharpLanguageCharacteristics" /> in the code.</returns> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType" />.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.GetSample(System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a sample symbol in the code.</summary> + <returns>A sample symbol in the code.</returns> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType" />.</param> + </member> + <member name="M:System.Web.Razor.Parser.CSharpLanguageCharacteristics.GetSymbolSample(System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a sample symbol in the code.</summary> + <returns>A sample symbol in the code.</returns> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType" />.</param> + </member> + <member name="P:System.Web.Razor.Parser.CSharpLanguageCharacteristics.Instance"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the instance for the <see cref="T:System.Web.Razor.Parser.CSharpLanguageCharacteristics" /> class.</summary> + <returns>The instance for the <see cref="T:System.Web.Razor.Parser.CSharpLanguageCharacteristics" /> class.</returns> + </member> + <member name="T:System.Web.Razor.Parser.HtmlLanguageCharacteristics"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the different language characteristics in an html.</summary> + </member> + <member name="M:System.Web.Razor.Parser.HtmlLanguageCharacteristics.CreateMarkerSymbol(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a marker symbol in the Html.</summary> + <returns>A marker symbol in the Html.</returns> + <param name="location">The source location.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlLanguageCharacteristics.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a symbol in the Html.</summary> + <returns>A symbol in the Html.</returns> + <param name="location">The source location.</param> + <param name="content">The content value.</param> + <param name="type">The html symbol type.</param> + <param name="errors">List of errors.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlLanguageCharacteristics.CreateTokenizer(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates an html tokenizer.</summary> + <returns>An html tokenizer.</returns> + <param name="source">The source of the text document.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlLanguageCharacteristics.FlipBracket(System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Flips the bracket symbol in the html.</summary> + <returns>The bracket symbol in the html.</returns> + <param name="bracket">The symbol bracket.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlLanguageCharacteristics.GetKnownSymbolType(System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the <see cref="T:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType" /> in the html.</summary> + <returns>The <see cref="T:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType" /> in the html.</returns> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType" />.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlLanguageCharacteristics.GetSample(System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a sample symbol in the html.</summary> + <returns>A sample symbol in the html.</returns> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType" />.</param> + </member> + <member name="P:System.Web.Razor.Parser.HtmlLanguageCharacteristics.Instance"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the instance for the <see cref="T:System.Web.Razor.Parser.HtmlLanguageCharacteristics" /> class.</summary> + <returns>The instance for the <see cref="T:System.Web.Razor.Parser.HtmlLanguageCharacteristics" /> class.</returns> + </member> + <member name="T:System.Web.Razor.Parser.HtmlMarkupParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a parser specifically for parsing HTML markup.</summary> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.HtmlMarkupParser" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.BuildSpan(System.Web.Razor.Parser.SyntaxTree.SpanBuilder,System.Web.Razor.Text.SourceLocation,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Builds the span for the given content using the specified span builder.</summary> + <param name="span">The span builder used to build the span.</param> + <param name="start">The start location.</param> + <param name="content">The span content.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.IsSpacingToken(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the function delegate used to determine the token used for HTML spacing.</summary> + <returns>The function delegate used to determine the token used for HTML spacing.</returns> + <param name="includeNewLines">true to indicate that new lines are considered as spacing token; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Parser.HtmlMarkupParser.Language"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the instance that defines the characteristics of HTML language.</summary> + <returns>The instance that defines the characteristics of HTML language.</returns> + </member> + <member name="P:System.Web.Razor.Parser.HtmlMarkupParser.OtherParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the other parser for parsing HTML markup.</summary> + <returns>The other parser for parsing HTML markup.</returns> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.OutputSpanBeforeRazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Builds the span before the Razor comment.</summary> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.ParseBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Parses the next HTML block.</summary> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.ParseDocument"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Parses the HTML document.</summary> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.ParseSection(System.Tuple{System.String,System.String},System.Boolean)"> + <summary>Parses a section with markups given by the nesting sequences.</summary> + <param name="nestingSequences">A tuple that specifies the markup nesting sequences.</param> + <param name="caseSensitive">true to indicate case-sensitive parsing; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.SkipToAndParseCode(System.Func{System.Web.Razor.Tokenizer.Symbols.HtmlSymbol,System.Boolean})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Skips the parse until the specified condition is meet.</summary> + <param name="condition">A function delegate that defines the condition.</param> + </member> + <member name="M:System.Web.Razor.Parser.HtmlMarkupParser.SkipToAndParseCode(System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Skips the parse until the specified HTML symbol type is encountered.</summary> + <param name="type">The HTML symbol type.</param> + </member> + <member name="P:System.Web.Razor.Parser.HtmlMarkupParser.VoidElements"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the HTML tags that are considered as void.</summary> + <returns>The HTML tags that are considered as void.</returns> + </member> + <member name="T:System.Web.Razor.Parser.LanguageCharacteristics`3"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Provides methods that define the behavior of a Razor code language.</summary> + <typeparam name="TTokenizer">The type of the code tokenizer for the Razor language.</typeparam> + <typeparam name="TSymbol">The type for the language symbol.</typeparam> + <typeparam name="TSymbolType">The enumeration type for the language symbol.</typeparam> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.LanguageCharacteristics`3" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.CreateMarkerSymbol(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a code language symbol with the specified source location as the start marker.</summary> + <returns>The symbol for the code language.</returns> + <param name="location">The source location as the start marker.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,`2,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a code language symbol with the specified source location with the specified source location as the start marker.</summary> + <returns>The symbol for the code language.</returns> + <param name="location">The source location as the start marker.</param> + <param name="content">The content.</param> + <param name="type">The enumeration type for the language symbol.</param> + <param name="errors">The collection of error.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.CreateTokenizer(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates a Razor code language tokenizer for the specified source document.</summary> + <returns>A Razor code language tokenizer for the specified source document.</returns> + <param name="source">The source document.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.FlipBracket(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the opposite bracket symbol for the specified bracket symbol.</summary> + <returns>The opposite bracket symbol for the specified bracket symbol.</returns> + <param name="bracket">The bracket symbol to flip.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.GetKnownSymbolType(System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the specific language symbol type for the given symbol type.</summary> + <returns>The specific language symbol type for the given symbol type.</returns> + <param name="type">The symbol type to get.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.GetSample(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the actual symbol for the given language symbol type.</summary> + <returns>The actual symbol for the given language symbol type.</returns> + <param name="type">The language symbol type to get.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsCommentBody(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is a comment body type.</summary> + <returns>true if the symbol is a comment body type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsCommentStar(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is a comment star type.</summary> + <returns>true if the symbol is a comment star type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsCommentStart(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is a comment start type.</summary> + <returns>true if the symbol is a comment start type; otherwise, false. </returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsIdentifier(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is an identifier type.</summary> + <returns>true if the symbol is an identifier type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsKeyword(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is a keyword type.</summary> + <returns>true if the symbol is a keyword type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsKnownSymbolType(`1,System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol type is a known symbol type.</summary> + <returns>true if the symbol type is a known symbol type; otherwise, false.</returns> + <param name="symbol">The symbol whose type is to be checked.</param> + <param name="type">The known type of the symbol.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsNewLine(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is a new line type.</summary> + <returns>true if the symbol is a new line type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsTransition(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is a transition type.</summary> + <returns>true if the symbol is a transition type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsUnknown(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is an unknown type.</summary> + <returns>true if the symbol is an unknown type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.IsWhiteSpace(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is a whitespace type.</summary> + <returns>true if the symbol is a whitespace type; otherwise, false.</returns> + <param name="symbol">The symbol to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.KnowsSymbolType(System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the symbol is an unknown type.</summary> + <returns>true if the symbol is an unknown type; otherwise, false.</returns> + <param name="type">The known type of the symbol.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.SplitSymbol(`1,System.Int32,`2)"> + <summary>Splits the content of the code language symbol at the specified index.</summary> + <returns>A tuple of code language symbol.</returns> + <param name="symbol">The symbol whose content is to be splitted.</param> + <param name="splitAt">The index where the split occurs.</param> + <param name="leftType">The enumeration type for the language symbol.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.TokenizeString(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Splits the specified string into tokens.</summary> + <returns>The collection of token.</returns> + <param name="content">The string to tokenize.</param> + </member> + <member name="M:System.Web.Razor.Parser.LanguageCharacteristics`3.TokenizeString(System.Web.Razor.Text.SourceLocation,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Splits the specified string into tokens.</summary> + <returns>The collection of token.</returns> + <param name="start">The source location as the start marker for the tokenizer.</param> + <param name="input">The string to tokenize.</param> + </member> + <member name="T:System.Web.Razor.Parser.ParserBase"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the parser base class for the razor.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserBase.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.ParserBase" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserBase.BuildSpan(System.Web.Razor.Parser.SyntaxTree.SpanBuilder,System.Web.Razor.Text.SourceLocation,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Builds a span for the parser base.</summary> + <param name="span">The span builder.</param> + <param name="start">The beginning of the source location.</param> + <param name="content">The content.</param> + </member> + <member name="P:System.Web.Razor.Parser.ParserBase.Context"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the <see cref="T:System.Web.Razor.Parser.ParserContext" />.</summary> + <returns>The <see cref="T:System.Web.Razor.Parser.ParserContext" />.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserBase.IsMarkupParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether the parser is a markup parser.</summary> + <returns>true if the parser is a markup parser; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserBase.OtherParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the other parser <see cref="T:System.Web.Razor.Parser.ParserBase" />.</summary> + <returns>The other parser <see cref="T:System.Web.Razor.Parser.ParserBase" />.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserBase.ParseBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Blocks the parser.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserBase.ParseDocument"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates documentation for the parse.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserBase.ParseSection(System.Tuple{System.String,System.String},System.Boolean)"> + <summary>Parses the section in ordered list of the elements.</summary> + <param name="nestingSequences">The pair of nesting sequences.</param> + <param name="caseSensitive">true if the case is sensitive; otherwise, false.</param> + </member> + <member name="T:System.Web.Razor.Parser.ParserContext"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a parser whose context can be switched to either a code or a markup.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.#ctor(System.Web.Razor.Text.ITextDocument,System.Web.Razor.Parser.ParserBase,System.Web.Razor.Parser.ParserBase,System.Web.Razor.Parser.ParserBase)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.ParserContext" /> class.</summary> + <param name="source">The source document.</param> + <param name="codeParser">The code parser for the context.</param> + <param name="markupParser">The markup parser for the context.</param> + <param name="activeParser">The active parser for the context.</param> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.ActiveParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the active parser for the context.</summary> + <returns>The active parser for the context.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.AddSpan(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds the specified span at the end of the block builder stack.</summary> + <param name="span">The span to add.</param> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.CodeParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the code parser for the context.</summary> + <returns>The code parser for the context.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.CompleteParse"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Parses the last span and returns the parse results that contain the newly built block.</summary> + <returns>The parse results that contain the newly built block.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.CurrentBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the current block builder.</summary> + <returns>The current block builder.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.CurrentCharacter"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the current character available from the source.</summary> + <returns>The current character available from the source.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.DesignTimeMode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets a value that indicates whether the parser is in design mode.</summary> + <returns>true if the parser is in design mode; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.EndBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Creates an end block from the last item of the block builder stack. </summary> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.EndOfFile"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets a value that indicates whether the source status is end of file.</summary> + <returns>true if the source status is end of file; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.Errors"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the list of errors during parsing.</summary> + <returns>The list of errors.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.IsWithin(System.Web.Razor.Parser.SyntaxTree.BlockType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified block type exists in the block builder list.</summary> + <returns>true if the specified block type exists in the block builder list; otherwise, false.</returns> + <param name="type">The block type to check.</param> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.LastAcceptedCharacters"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the last accepted characters.</summary> + <returns>One of the values of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters" /> enumeration.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.LastSpan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the last span.</summary> + <returns>The last span.</returns> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.MarkupParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the markup parser for the context.</summary> + <returns>The markup parser for the context.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.OnError(System.Web.Razor.Text.SourceLocation,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Occurs when parse encountered error.</summary> + <param name="location">The source location.</param> + <param name="message">The error message.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.OnError(System.Web.Razor.Text.SourceLocation,System.String,System.Object[])"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Occurs when parse encountered an error.</summary> + <param name="location">The source location.</param> + <param name="message">The error message.</param> + <param name="args">The other information about the source location.</param> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.Source"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the text reader for the source document.</summary> + <returns>The text reader for the source document.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.StartBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds a new block builder at the end of the block builder stack and returns a disposable action that returns an end block.</summary> + <returns>A disposable action that returns an end block.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.StartBlock(System.Web.Razor.Parser.SyntaxTree.BlockType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Adds a new block builder at the end of the block builder stack and returns a disposable action that returns an end block.</summary> + <returns>A disposable action that returns an end block.</returns> + <param name="blockType">The type for the new block builder.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserContext.SwitchActiveParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Alternately switches the code parser or markup parser as the active parser.</summary> + </member> + <member name="P:System.Web.Razor.Parser.ParserContext.WhiteSpaceIsSignificantToAncestorBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets a value that indicates whether white space is significant to ancestor block.</summary> + <returns>true is white space is significant to ancestor block; otherwise, false.</returns> + </member> + <member name="T:System.Web.Razor.Parser.ParserHelpers"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Provides helper methods for the parser.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsCombining(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a spacing combining mark or a non-spacing mark.</summary> + <returns>true if the specified character value is a spacing combining mark or a non-spacing mark; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsConnecting(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a connector punctuation.</summary> + <returns>true if the specified character value is a connector punctuation; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsDecimalDigit(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a decimal digit number.</summary> + <returns>true if the specified character value is a decimal digit number; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsEmailPart(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is valid for use in email address.</summary> + <returns>true if the specified character value is valid for use in email address; otherwise, false.</returns> + <param name="character">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsFormatting(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is used for formatting text layout or formatting text operation.</summary> + <returns>true if the specified character value is used for formatting text layout or formatting text operation.; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsHexDigit(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a hexadecimal digit number.</summary> + <returns>true if the specified character is a hexadecimal digit number; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsIdentifier(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified string value is an identifier.</summary> + <returns>true if the specified string value is an identifier; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsIdentifier(System.String,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified string value is an identifier.</summary> + <returns>true if the specified string value is an identifier; otherwise, false.</returns> + <param name="value">The value to check.</param> + <param name="requireIdentifierStart">true to require that the identifier starts with a letter or underscore (_); otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsIdentifierPart(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is valid for use in identifier.</summary> + <returns>true if the specified character is valid for use in identifier; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsIdentifierStart(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is valid for use as start character of an identifier.</summary> + <returns>true if the specified character value is valid for use as start character of an identifier; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsLetter(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a letter.</summary> + <returns>true if the specified character is a letter; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsLetterOrDecimalDigit(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a letter or a decimal digit number.</summary> + <returns>true if the specified character is a letter or a decimal digit number; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsNewLine(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified value is a newline.</summary> + <returns>true if the specified character is a newline; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsNewLine(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified value is a newline.</summary> + <returns>true if the specified character is a newline; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsTerminatingCharToken(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a terminating character token.</summary> + <returns>true if the specified character value is a terminating character token; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsTerminatingQuotedStringToken(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a terminating quoted string.</summary> + <returns>true if the specified character value is a terminating quoted string; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsWhitespace(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a whitespace.</summary> + <returns>true if the specified character value is a whitespace; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.IsWhitespaceOrNewLine(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified character value is a whitespace or newline.</summary> + <returns>true if the specified character value is a whitespace or newline; otherwise, false.</returns> + <param name="value">The value to check.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserHelpers.SanitizeClassName(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Sanitizes the specified input name to conform as a valid value for class name.</summary> + <returns>The sanitized class name.</returns> + <param name="inputName">The value to check.</param> + </member> + <member name="T:System.Web.Razor.Parser.ParserVisitor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a parser visitor.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.ParserVisitor" /> class.</summary> + </member> + <member name="P:System.Web.Razor.Parser.ParserVisitor.CancelToken"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the cancellation token.</summary> + <returns>The cancellation token.</returns> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.OnComplete"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates that a visitor method has completed execution.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.ThrowIfCanceled"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.VisitBlock(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the specified block.</summary> + <param name="block">The block to visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.VisitEndBlock(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the specified black after parsing.</summary> + <param name="block">The block to visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.VisitError(System.Web.Razor.Parser.SyntaxTree.RazorError)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the given razor error.</summary> + <param name="err">The error to visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.VisitSpan(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the specified span.</summary> + <param name="span">The span to visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitor.VisitStartBlock(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Visits the specified block before parsing.</summary> + <param name="block">The block to visit.</param> + </member> + <member name="T:System.Web.Razor.Parser.ParserVisitorExtensions"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Provides extension methods for parser visitor.</summary> + </member> + <member name="M:System.Web.Razor.Parser.ParserVisitorExtensions.Visit(System.Web.Razor.Parser.ParserVisitor,System.Web.Razor.ParserResults)"></member> + <member name="T:System.Web.Razor.Parser.RazorParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a Razor parser.</summary> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.#ctor(System.Web.Razor.Parser.ParserBase,System.Web.Razor.Parser.ParserBase)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.RazorParser" /> class.</summary> + <param name="codeParser">The code parser.</param> + <param name="markupParser">The markup parser.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.CreateParseTask(System.IO.TextReader,System.Action{System.Web.Razor.Parser.SyntaxTree.Span},System.Action{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a task that parses a specified object.</summary> + <returns>The created <see cref="T:System.Threading.Tasks.Task" />.</returns> + <param name="input">The object to parse.</param> + <param name="spanCallback">The span callback.</param> + <param name="errorCallback">The error callback.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.CreateParseTask(System.IO.TextReader,System.Action{System.Web.Razor.Parser.SyntaxTree.Span},System.Action{System.Web.Razor.Parser.SyntaxTree.RazorError},System.Threading.CancellationToken)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a task that parses a specified object.</summary> + <returns>The created <see cref="T:System.Threading.Tasks.Task" />.</returns> + <param name="input">The object to parse.</param> + <param name="spanCallback">The span callback.</param> + <param name="errorCallback">The error callback.</param> + <param name="cancelToken">The cancellation token.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.CreateParseTask(System.IO.TextReader,System.Action{System.Web.Razor.Parser.SyntaxTree.Span},System.Action{System.Web.Razor.Parser.SyntaxTree.RazorError},System.Threading.SynchronizationContext)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a task that parses a specified object.</summary> + <returns>The created <see cref="T:System.Threading.Tasks.Task" />.</returns> + <param name="input">The object to parse.</param> + <param name="spanCallback">The span callback.</param> + <param name="errorCallback">The error callback.</param> + <param name="context">The context.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.CreateParseTask(System.IO.TextReader,System.Action{System.Web.Razor.Parser.SyntaxTree.Span},System.Action{System.Web.Razor.Parser.SyntaxTree.RazorError},System.Threading.SynchronizationContext,System.Threading.CancellationToken)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a task that parses a specified object.</summary> + <returns>The created <see cref="T:System.Threading.Tasks.Task" />.</returns> + <param name="input">The object to parse.</param> + <param name="spanCallback">The span callback.</param> + <param name="errorCallback">The error callback.</param> + <param name="context">The context.</param> + <param name="cancelToken">The cancellation token.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.CreateParseTask(System.IO.TextReader,System.Web.Razor.Parser.ParserVisitor)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a task that parses a specified object.</summary> + <returns>The created <see cref="T:System.Threading.Tasks.Task" />.</returns> + <param name="input">The object to parse.</param> + <param name="consumer">The consumer.</param> + </member> + <member name="P:System.Web.Razor.Parser.RazorParser.DesignTimeMode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the design time mode.</summary> + <returns>The design time mode.</returns> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.Parse(System.IO.TextReader)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the specified object.</summary> + <returns>The parser result.</returns> + <param name="input">The object to parse.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.Parse(System.IO.TextReader,System.Web.Razor.Parser.ParserVisitor)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the specified object.</summary> + <param name="input">The object to parse.</param> + <param name="visitor">The visitor.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.Parse(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the specified object.</summary> + <returns>The parser result.</returns> + <param name="input">The object to parse.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.Parse(System.Web.Razor.Text.LookaheadTextReader)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the specified object.</summary> + <returns>The parser result.</returns> + <param name="input">The object to parse.</param> + </member> + <member name="M:System.Web.Razor.Parser.RazorParser.Parse(System.Web.Razor.Text.LookaheadTextReader,System.Web.Razor.Parser.ParserVisitor)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the specified object.</summary> + <param name="input">The object to parse.</param> + <param name="visitor">The visitor.</param> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxConstants"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.EndCommentSequence"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.StartCommentSequence"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.TextTagName"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.TransitionCharacter"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.TransitionString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxConstants.CSharp"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.ClassKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.ElseIfKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.FunctionsKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.HelperKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.InheritsKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.LayoutKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.NamespaceKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.SectionKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.SessionStateKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.CSharp.UsingKeywordLength"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxConstants.VB"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.CodeKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.EndCodeKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.EndFunctionsKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.EndHelperKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.EndKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.EndSectionKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.ExplicitKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.FunctionsKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.HelperKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.ImportsKeywordLength"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.LayoutKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.OffKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.SectionKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.SelectCaseKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.SessionStateKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxConstants.VB.StrictKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Parser.TokenizerBackedParser`3"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a tokenizer backed parser.</summary> + <typeparam name="TTokenizer">The type of tokenizer.</typeparam> + <typeparam name="TSymbol">The type of symbol.</typeparam> + <typeparam name="TSymbolType">The type of SymbolType.</typeparam> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.TokenizerBackedParser`3" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Accept(System.Collections.Generic.IEnumerable{`1})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the list of symbols</summary> + <param name="symbols">The list of symbols.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Accept(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the specified symbol.</summary> + <param name="symbol">The symbol to accept.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptAll(`2[])"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parser accepts all types of tokenizer.</summary> + <returns>true of the parser accepts all types of tokenizer; otherwise, false.</returns> + <param name="types">The types.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptAndMoveNext"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parser accepts and moves to the next tokenizer.</summary> + <returns>true if the parser accepts and moves to the next tokenizer; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptSingleWhiteSpaceCharacter"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parser accepts single whitespace character.</summary> + <returns>true if the parser accepts single whitespace character; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptUntil(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts token until a token of the given type is found.</summary> + <param name="type">The type of the token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptUntil(`2,`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts token until a token of the given type is found and it will backup so that the next token is of the given type.</summary> + <param name="type1">The type of the first token.</param> + <param name="type2">The type of the second token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptUntil(`2,`2,`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the given tokens until a token of the given type is found.</summary> + <param name="type1">The type of the first token.</param> + <param name="type2">The type of the second token.</param> + <param name="type3">The type of the third token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptUntil(`2[])"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts token until a token of the given types is found.</summary> + <param name="types">The types of the token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptWhile(System.Func{`1,System.Boolean})"> + <summary>Accepts token while the condition has been reached.</summary> + <param name="condition">The condition.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptWhile(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the token while a token of the given type is not found.</summary> + <param name="type">The type of the token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptWhile(`2,`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts token while the token of the given type has been reached.</summary> + <param name="type1">The type of the first token.</param> + <param name="type2">The type of the second token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptWhile(`2,`2,`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts token while the token of the given type has been reached.</summary> + <param name="type1">The type of the first token.</param> + <param name="type2">The type of the second token.</param> + <param name="type3">The type of the third token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptWhile(`2[])"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts token while the token of the given types has been reached.</summary> + <param name="types">The types.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AcceptWhiteSpaceInLines"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parser accepts whitespace in lines.</summary> + <returns>true if the parser accepts whitespace in lines; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AddMarkerSymbolIfNecessary"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Adds a marker symbol if necessary.</summary> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AddMarkerSymbolIfNecessary(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Adds a marker symbol if necessary.</summary> + <param name="location">The location where to add the symbol.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.At(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the token is at the specified type.</summary> + <returns>true if the token is at the specified type; otherwise, false.</returns> + <param name="type">The type.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.AtIdentifier(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the token is at the specified identifier.</summary> + <returns>true if the token is at the specified identifier; otherwise, false.</returns> + <param name="allowKeywords">true to allow keywords; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Balance(System.Web.Razor.Parser.BalancingModes)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parsing is balance.</summary> + <returns>true if the parsing is balance; otherwise, false.</returns> + <param name="mode">The balancing mode.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Balance(System.Web.Razor.Parser.BalancingModes,`2,`2,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parsing is balance.</summary> + <returns>true if the parsing is balance; otherwise, false.</returns> + <param name="mode">The balancing mode.</param> + <param name="left">The left parse.</param> + <param name="right">The right parse.</param> + <param name="start">The start of the mode.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.BuildSpan(System.Web.Razor.Parser.SyntaxTree.SpanBuilder,System.Web.Razor.Text.SourceLocation,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Builds a specified span.</summary> + <param name="span">The span to build.</param> + <param name="start">The start location to build the span.</param> + <param name="content">The content of the span.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.ConfigureSpan(System.Action{System.Web.Razor.Parser.SyntaxTree.SpanBuilder})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Configures the span.</summary> + <param name="config">The configuration.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.ConfigureSpan(System.Action{System.Web.Razor.Parser.SyntaxTree.SpanBuilder,System.Action{System.Web.Razor.Parser.SyntaxTree.SpanBuilder}})"> + <summary>Configures the span.</summary> + <param name="config">The configuration.</param> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.CurrentLocation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current location of the current instance.</summary> + <returns>The current location of the current instance.</returns> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.CurrentSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current symbol of this instance.</summary> + <returns>The current symbol of this instance.</returns> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.EndOfFile"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value indicating whether the tokenizer is in the end of file.</summary> + <returns>true if the tokenizer is in the end of file; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.EnsureCurrent"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether to ensure the current parser.</summary> + <returns>true if to ensure the current parser; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Expected(System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the expected token with the given type.</summary> + <param name="type">The type.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Expected(`2[])"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the expected token with the given types.</summary> + <param name="types">The types.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.HandleEmbeddedTransition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Handles the embedded transition.</summary> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Initialize(System.Web.Razor.Parser.SyntaxTree.SpanBuilder)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a specified span.</summary> + <param name="span">The span to initialize.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.IsAtEmbeddedTransition(System.Boolean,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether this instance is at embedded transition.</summary> + <returns>true if this instance is at embedded transition; otherwise, false.</returns> + <param name="allowTemplatesAndComments">true to allow templates and comments; otherwise, false.</param> + <param name="allowTransitions">true to allow transitions; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.Language"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the language used for parsing.</summary> + <returns>The language used for parsing.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.NextIs(System.Func{`1,System.Boolean})"> + <summary>Determines whether the token with the given condition would pass.</summary> + <returns>true if the token with the given condition would pass; otherwise, false.</returns> + <param name="condition">The condition.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.NextIs(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the token with the given type would pass.</summary> + <returns>true if the token with the give type would pass; otherwise, false.</returns> + <param name="type">The type of the token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.NextIs(`2[])"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the token with the given types would pass.</summary> + <returns>true if the token with the given types would pass; otherwise, false.</returns> + <param name="types">The types.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.NextToken"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the parser advances to the next token.</summary> + <returns>true if the parser advances to the next token; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Optional(System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether parsing a token with the given type is optional.</summary> + <returns>true if parsing a token with the given type is optional; otherwise, false.</returns> + <param name="type">The type of the token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Optional(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether parsing a token with the given type is optional.</summary> + <returns>true if parsing a token with the given type is optional; otherwise, false.</returns> + <param name="type">The type of the token.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Output(System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Outputs a token with accepted characters.</summary> + <param name="accepts">The accepted characters.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Output(System.Web.Razor.Parser.SyntaxTree.SpanKind)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Outputs a token with span kind.</summary> + <param name="kind">The span kind.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Output(System.Web.Razor.Parser.SyntaxTree.SpanKind,System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Outputs a token with a given span kind and accepted characters.</summary> + <param name="kind">The span kind.</param> + <param name="accepts">The accepted characters.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.OutputSpanBeforeRazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Outputs a span before the razor comment.</summary> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.PreviousSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code..Gets the previous symbol of this instance.</summary> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.PushSpanConfig"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Pushes the span configuration.</summary> + <returns>An <see cref="T:System.IDisposable" /> that shuts down the configuration.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.PushSpanConfig(System.Action{System.Web.Razor.Parser.SyntaxTree.SpanBuilder})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Pushes the span configuration.</summary> + <returns>An <see cref="T:System.IDisposable" /> that shuts down the configuration.</returns> + <param name="newConfig">The new configuration.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.PushSpanConfig(System.Action{System.Web.Razor.Parser.SyntaxTree.SpanBuilder,System.Action{System.Web.Razor.Parser.SyntaxTree.SpanBuilder}})"> + <summary>Pushes the span configuration.</summary> + <returns>An <see cref="T:System.IDisposable" /> that shuts down the configuration.</returns> + <param name="newConfig">The new configuration.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.PutBack(System.Collections.Generic.IEnumerable{`1})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Puts the transition back.</summary> + <param name="symbols">The symbols.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.PutBack(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Puts the transition back.</summary> + <param name="symbol">The symbol.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.PutCurrentBack"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Puts the current transition back.</summary> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.RazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Displays the razor comment.</summary> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.ReadWhile(System.Func{`1,System.Boolean})"> + <summary>Reads a token while the condition is not reached.</summary> + <returns>The token to read.</returns> + <param name="condition">The condition.</param> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Required(`2,System.Boolean,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the expected token is required.</summary> + <returns>true if the expected token is required; otherwise, false.</returns> + <param name="expected">The expected token.</param> + <param name="errorIfNotFound">true to display an error if not found; otherwise, false.</param> + <param name="errorBase">The error base.</param> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.Span"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the <see cref="T:System.Web.Razor.Parser.SyntaxTree.SpanBuilder" /> associated with this instance.</summary> + <returns>The <see cref="T:System.Web.Razor.Parser.SyntaxTree.SpanBuilder" /> associated with this instance.</returns> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.SpanConfig"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the span configuration.</summary> + <returns>The span configuration.</returns> + </member> + <member name="P:System.Web.Razor.Parser.TokenizerBackedParser`3.Tokenizer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the tokenizer.</summary> + <returns>The tokenizer.</returns> + </member> + <member name="M:System.Web.Razor.Parser.TokenizerBackedParser`3.Was(`2)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the token with the given type was parsed.</summary> + <returns>true if the token with the given type was parsed; otherwise, false.</returns> + <param name="type">The type of the token.</param> + </member> + <member name="T:System.Web.Razor.Parser.VBCodeParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a Visual Basic code parser.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.VBCodeParser" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.AcceptVBSpaces"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts spaces in the VB code.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.Assert(System.Web.Razor.Tokenizer.Symbols.VBKeyword)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Checks for a condition and displays a keyword in the code.</summary> + <param name="keyword">The keyword.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.AssertDirective(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Asserts the given directive.</summary> + <param name="directive">The directive to assert.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.At(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the directive is ‘AT’ directive.</summary> + <returns>true if the directive is an ‘AT’ directive; otherwise, false.</returns> + <param name="directive">The directive.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.At(System.Web.Razor.Tokenizer.Symbols.VBKeyword)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the given keyword is ‘AT’.</summary> + <returns>true if the given keyword is ‘AT’; otherwise, false.</returns> + <param name="keyword">The keyword.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.EndTerminatedDirective(System.String,System.Web.Razor.Parser.SyntaxTree.BlockType,System.Web.Razor.Generator.SpanCodeGenerator,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Ends a terminated directive.</summary> + <returns>The function that ends the terminated directive.</returns> + <param name="directive">The directive.</param> + <param name="blockType">The block type.</param> + <param name="codeGenerator">The code generator.</param> + <param name="allowMarkup">true to allow markup; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.EndTerminatedDirectiveBody(System.String,System.Web.Razor.Text.SourceLocation,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the termination of directive body is ended.</summary> + <returns>true if the termination of directive body is ended; otherwise, false.</returns> + <param name="directive">The directive.</param> + <param name="blockStart">The block start.</param> + <param name="allowAllTransitions">true to allow all transitions; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.EndTerminatedStatement(System.Web.Razor.Tokenizer.Symbols.VBKeyword,System.Boolean,System.Boolean)"> + <summary>Ends a termination of statement.</summary> + <returns>The function that ends the termination.</returns> + <param name="keyword">The keyword.</param> + <param name="supportsExit">true if the termination supports exit; otherwise, false.</param> + <param name="supportsContinue">true if the termination supports continue; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.EndTerminatedStatement(System.Web.Razor.Tokenizer.Symbols.VBKeyword,System.Boolean,System.Boolean,System.String)"> + <summary>Ends a termination of statement.</summary> + <returns>The function that ends the termination.</returns> + <param name="keyword">The keyword.</param> + <param name="supportsExit">true if the termination supports exit; otherwise, false.</param> + <param name="supportsContinue">true if the termination supports continue; otherwise, false.</param> + <param name="blockName">The block name.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.HandleEmbeddedTransition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Handles the embedded transition.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.HandleEmbeddedTransition(System.Web.Razor.Tokenizer.Symbols.VBSymbol)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Handles the embedded transition.</summary> + <param name="lastWhiteSpace">The last white space.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.HandleExitOrContinue(System.Web.Razor.Tokenizer.Symbols.VBKeyword)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the code that handles the Exit or Continue keyword.</summary> + <param name="keyword">The keyword.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.HandleTransition(System.Web.Razor.Tokenizer.Symbols.VBSymbol)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a code that handles a transition.</summary> + <param name="lastWhiteSpace">The last white space.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.HelperDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates whether the code is a helper directive.</summary> + <returns>true if the code is a helper directive; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.ImportsStatement"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code imports a statement.</summary> + <returns>true if the code imports a statement; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.InheritsStatement"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code inherits a statement.</summary> + <returns>true if the code inherits a statement; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.IsAtEmbeddedTransition(System.Boolean,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code is at embedded transition.</summary> + <returns>true if the code is at embedded transition; otherwise, false.</returns> + <param name="allowTemplatesAndComments">true to allow templates and comments; otherwise, false.</param> + <param name="allowTransitions">true to allow transitions; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.IsDirectiveDefined(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code is directive defined.</summary> + <returns>true if the code is directive defined; otherwise, false.</returns> + <param name="directive">The directive.</param> + </member> + <member name="P:System.Web.Razor.Parser.VBCodeParser.Keywords"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the keywords associated with the code.</summary> + <returns>The keywords associated with the code.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.KeywordTerminatedStatement(System.Web.Razor.Tokenizer.Symbols.VBKeyword,System.Web.Razor.Tokenizer.Symbols.VBKeyword,System.Boolean,System.Boolean)"> + <summary>Indicates a keyword that terminates a statement.</summary> + <returns>The function that terminates the statement.</returns> + <param name="start">The start.</param> + <param name="terminator">The terminator.</param> + <param name="supportsExit">true if the termination supports exit; otherwise, false.</param> + <param name="supportsContinue">true if the termination supports continue; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Parser.VBCodeParser.Language"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the language for the parser.</summary> + <returns>The language for the parser.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.LayoutDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code is a layout directive.</summary> + <returns>true if the code is a layout directive; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.MapDirective(System.String,System.Func{System.Boolean})"> + <summary>Maps a given directive.</summary> + <param name="directive">The directive.</param> + <param name="action">The action whether to map a given directive.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.MapKeyword(System.Web.Razor.Tokenizer.Symbols.VBKeyword,System.Func{System.Boolean})"> + <summary>Maps a given keyword.</summary> + <param name="keyword">The keyword.</param> + <param name="action">The action whether to map a given keyword.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.NestedBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a nested block.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.Optional(System.Web.Razor.Tokenizer.Symbols.VBKeyword)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the keyword from the code is optional.</summary> + <returns>true if the keyword from the code is optional; otherwise, false.</returns> + <param name="keyword">The keyword.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.OptionStatement"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code is an option statement.</summary> + <returns>true if the code is an option statement; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Parser.VBCodeParser.OtherParser"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the other parser.</summary> + <returns>The other parser.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.OtherParserBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the parser block.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.OtherParserBlock(System.String,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the parser block.</summary> + <param name="startSequence">The start sequence.</param> + <param name="endSequence">The end sequence.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.OutputSpanBeforeRazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Spans the output before Razor comment.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.ParseBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Blocks the parsing.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.ReadVBSpaces"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Reads a list of Visual Basic spaces.</summary> + <returns>A list of Visual Basic spaces.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.Required(System.Web.Razor.Tokenizer.Symbols.VBSymbolType,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the expected symbol is required.</summary> + <returns>true if the expected symbol is required; otherwise, false.</returns> + <param name="expected">The expected symbol.</param> + <param name="errorBase">The error base.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.ReservedWord"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code is a reserved word.</summary> + <returns>true if the code is a reserved word; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.SectionDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code is a section directive.</summary> + <returns>true if the code is a section directive; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Parser.VBCodeParser.SessionStateDirective"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the code has a session state directive.</summary> + <returns>true if the code has a session state directive; otherwise, false.</returns> + </member> + <member name="T:System.Web.Razor.Parser.VBLanguageCharacteristics"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the characteristics of the Visual Basic language.</summary> + </member> + <member name="M:System.Web.Razor.Parser.VBLanguageCharacteristics.CreateMarkerSymbol(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a Visual Basic marker symbol.</summary> + <returns>The created Visual Basic marker symbol.</returns> + <param name="location">The location to create the symbol.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBLanguageCharacteristics.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.VBSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a Visual Basic symbol.</summary> + <returns>The created <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbol" />.</returns> + <param name="location">The location to create the symbol.</param> + <param name="content">The content.</param> + <param name="type">The type of the symbol.</param> + <param name="errors">The errors.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBLanguageCharacteristics.CreateTokenizer(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a Visual Basic tokenizer.</summary> + <returns>The created <see cref="T:System.Web.Razor.Tokenizer.VBTokenizer" />.</returns> + <param name="source">The source where to create the tokenizer.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBLanguageCharacteristics.FlipBracket(System.Web.Razor.Tokenizer.Symbols.VBSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Flips the given bracket.</summary> + <returns>The type of the Visual Basic symbol.</returns> + <param name="bracket">The bracket to flip.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBLanguageCharacteristics.GetKnownSymbolType(System.Web.Razor.Tokenizer.Symbols.KnownSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Retrieves the type of the known symbol.</summary> + <returns>The type of the known symbol.</returns> + <param name="type">The type to retrieve.</param> + </member> + <member name="M:System.Web.Razor.Parser.VBLanguageCharacteristics.GetSample(System.Web.Razor.Tokenizer.Symbols.VBSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a sample symbol with the given type.</summary> + <returns>A sample symbol with the given type.</returns> + <param name="type">The type of the symbol.</param> + </member> + <member name="P:System.Web.Razor.Parser.VBLanguageCharacteristics.Instance"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets an instance of this <see cref="T:System.Web.Razor.Parser.VBLanguageCharacteristics" />.</summary> + <returns>An instance of <see cref="T:System.Web.Razor.Parser.VBLanguageCharacteristics" />.</returns> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters.AllWhiteSpace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters.Any"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters.AnyExceptNewline"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters.NewLine"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters.None"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters.NonWhiteSpace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters.WhiteSpace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the auto-complete editing handler class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.#ctor(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}})"> + <summary>Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler" /> class.</summary> + <param name="tokenizer">The tokenizer.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.#ctor(System.Func{System.String,System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}},System.Web.Razor.Parser.SyntaxTree.AcceptedCharacters)"> + <summary>Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler" /> class.</summary> + <param name="tokenizer">The tokenizer.</param> + <param name="accepted">The accepted characters.</param> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.AutoCompleteAtEndOfSpan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value that indicates whether the auto-complete function is at the end of this span.</summary> + <returns>true if the auto-complete function is at the end of this span; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.AutoCompleteString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a string value to auto-complete.</summary> + <returns>A string value to auto-complete.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.CanAcceptChange(System.Web.Razor.Parser.SyntaxTree.Span,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a parse result that can accept changes.</summary> + <param name="target">The phase of the target.</param> + <param name="normalizedChange">The normalized <see cref="T:System.Web.Razor.Text.TextChange" />.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates whether this instance and a specified object are equal.</summary> + <returns>true if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, false.</returns> + <param name="obj">The object.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>A 32-bit signed integer that is the hash code for this instance.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.AutoCompleteEditHandler.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the fully qualified type name of this instance.</summary> + <returns>A String containing a fully qualified type name.</returns> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.Block"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the block for creating webpages.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.#ctor(System.Web.Razor.Parser.SyntaxTree.BlockBuilder)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.Block" /> class.</summary> + <param name="source">The source for the block builder.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.Accept(System.Web.Razor.Parser.ParserVisitor)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the parser visitor of the block.</summary> + <param name="visitor">The parser visitor.</param> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Block.Children"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a collection of SyntaxTreeNode to view the children of the block.</summary> + <returns>A collection of SyntaxTreeNode to view the children of the block.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Block.CodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the IBlockCodeGenerator to generate codes for the elements.</summary> + <returns>The IBlockCodeGenerator to generate codes for the elements.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current block.</summary> + <returns>true if the specified object is equal to the current block; otherwise, false.</returns> + <param name="obj">The object to compare with the current object.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.EquivalentTo(System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a value indicating whether the block is equivalent to the same element.</summary> + <returns>true if the block is equivalent to the same element; otherwise, false.</returns> + <param name="node">The syntax tree node.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.FindFirstDescendentSpan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Finds the first descendent span of the block.</summary> + <returns>The first descendent span of the block.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.FindLastDescendentSpan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Finds the last descendent span of the block.</summary> + <returns>The last descendent span of the block.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.Flatten"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Flattens a collection of a specified type for the block.</summary> + <returns>A collection of a specified type for the block to flatten.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Block.IsBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether the object is a block-level object.</summary> + <returns>true if the object is a block-level object; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Block.Length"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the length value of the block.</summary> + <returns>The length value of the block.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.LocateOwner(System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Locates the owner of the block.</summary> + <returns>The owner of the block to locate.</returns> + <param name="change">The text change.</param> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Block.Name"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the string name of the block.</summary> + <returns>The string name of the block.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Block.Start"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the start to identify the specific location of the block.</summary> + <returns>The start to identify the specific location of the block.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Block.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string that represents the current object.</summary> + <returns>A string that represents the current object.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Block.Type"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the type of code block.</summary> + <returns>The type of code block.</returns> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.BlockBuilder"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the block builder for the webpages.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.BlockBuilder" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.#ctor(System.Web.Razor.Parser.SyntaxTree.Block)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.BlockBuilder" /> class.</summary> + <param name="original">The original block builder.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.Build"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Builds a block for this instance.</summary> + <returns>A block builds for this instance.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.Children"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the collection of child elements of the block builder.</summary> + <returns>The collection of child elements of the block builder.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.CodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the code generator for the block builder.</summary> + <returns>The code generator for the block builder.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.Name"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the string name for the block builder.</summary> + <returns>The string name for the block builder.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.Reset"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Resets the block builder to its original position.</summary> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.BlockBuilder.Type"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a block type that can be assigned null.</summary> + <returns>A block type that can be assigned null.</returns> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.BlockType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Comment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Directive"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Expression"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Functions"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Helper"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Markup"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Section"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Statement"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.BlockType.Template"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.RazorError"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a parsing error in Razor.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.#ctor(System.String,System.Int32,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.RazorError" /> class.</summary> + <param name="message">The error message.</param> + <param name="absoluteIndex">The absolute index of the source location.</param> + <param name="lineIndex">The line index of the source location.</param> + <param name="columnIndex">The column index of the source location.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.#ctor(System.String,System.Int32,System.Int32,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.RazorError" /> class.</summary> + <param name="message">The error message.</param> + <param name="absoluteIndex">The absolute index of the source location.</param> + <param name="lineIndex">The line index of the source location.</param> + <param name="columnIndex">The column index of the source location.</param> + <param name="length">The length for the error.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.#ctor(System.String,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.RazorError" /> class.</summary> + <param name="message">The error message.</param> + <param name="location">The source location of the error.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.#ctor(System.String,System.Web.Razor.Text.SourceLocation,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.RazorError" /> class.</summary> + <param name="message">The error message.</param> + <param name="location">The source location of the error.</param> + <param name="length">The length for the error.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this instance.</summary> + <returns>true if the specified object is equal to this instance; otherwise, false.</returns> + <param name="obj">The object to compare to this instance.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.Equals(System.Web.Razor.Parser.SyntaxTree.RazorError)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this instance.</summary> + <returns>true if the specified object is equal to this instance; otherwise, false.</returns> + <param name="other">The object to compare to this instance.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the hash code for the current instance.</summary> + <returns>The hash code for the current instance.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.RazorError.Length"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the length for the error.</summary> + <returns>The length for the error.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.RazorError.Location"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the source location of the error.</summary> + <returns>The source location of the error.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.RazorError.Message"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the error message.</summary> + <returns>The error message.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.RazorError.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation of this error instance.</summary> + <returns>The string representation of this error instance.</returns> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.Span"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Represents a Razor parse tree node that contains the all the content of a block node.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.#ctor(System.Web.Razor.Parser.SyntaxTree.SpanBuilder)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.Span" /> class.</summary> + <param name="builder">The builder to use for this span.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.Accept(System.Web.Razor.Parser.ParserVisitor)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Accepts visit from the specified visitor.</summary> + <param name="visitor">The object that performs the visit.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.Change(System.Action{System.Web.Razor.Parser.SyntaxTree.SpanBuilder})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Changes the span builder for this span.</summary> + <param name="changes">A delegate that will be executed along with this change.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.ChangeStart(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Sets the start character location of this span.</summary> + <param name="newStart">The new start location to set for this span.</param> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.CodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the code generator for the span.</summary> + <returns>The code generator for the span.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.Content"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the content of the span.</summary> + <returns>The content of the span.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.EditHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the handler for span edits.</summary> + <returns>The handler for span edits.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified object is equal to this span.</summary> + <returns>true if the specified object is equal to this span; otherwise, false.</returns> + <param name="obj">The object to compare to this span.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.EquivalentTo(System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Determines whether the specified node is equivalent to this span.</summary> + <returns>true if the specified node is equal to this span; otherwise, false.</returns> + <param name="node">The node to compare with this span.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the hash code for this current span.</summary> + <returns>The hash code for this current span.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.IsBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets a value that indicates whether this node is a block node.</summary> + <returns>false.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.Kind"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the kind for this span.</summary> + <returns>One of the values of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.SpanKind" /> enumeration.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.Length"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the length of the span content.</summary> + <returns>The length of the span content.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.Next"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the next span in the tree node.</summary> + <returns>The next span in the tree node.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.Previous"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the previous span in the tree node.</summary> + <returns>The previous span in the tree node.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.ReplaceWith(System.Web.Razor.Parser.SyntaxTree.SpanBuilder)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Replaces the span builder for this span with the specified span builder.</summary> + <param name="builder">The new builder to use for this span.</param> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.Start"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the start character location of the span.</summary> + <returns>The start character location of the span.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.Span.Symbols"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the symbols used to generate the code for the span.</summary> + <returns>The symbols used to generate the code for the span.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.Span.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the string representation of this current span.</summary> + <returns>The string representation of this current span.</returns> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.SpanBuilder"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the span builder for the syntax tree.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.SpanBuilder" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.#ctor(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.SpanBuilder" /> class.</summary> + <param name="original">The original span.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.Accept(System.Web.Razor.Tokenizer.Symbols.ISymbol)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the given symbol for the span builder.</summary> + <param name="symbol">The symbol builder.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.Build"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Builds a span builder for this instance.</summary> + <returns>A span builder for this instance.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.ClearSymbols"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Clears the symbols of the span builder.</summary> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.CodeGenerator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the span code generator.</summary> + <returns>The span code generator.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.EditHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the span edit handler of the builder.</summary> + <returns>The span edit handler of the builder.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.Kind"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the span kind of the span builder.</summary> + <returns>The span kind of the span builder.</returns> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.Reset"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Resets the span builder.</summary> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.Start"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the source location of the span builder.</summary> + <returns>The source location of the span builder.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SpanBuilder.Symbols"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the symbols for a generic read-only collection.</summary> + <returns>The symbols for a generic read-only collection.</returns> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.SpanKind"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.SpanKind.Code"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.SpanKind.Comment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.SpanKind.Markup"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.SpanKind.MetaCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Parser.SyntaxTree.SpanKind.Transition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the node for the syntax tree.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode.Accept(System.Web.Razor.Parser.ParserVisitor)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the visitor of the tree node.</summary> + <param name="visitor">The parser visitor.</param> + </member> + <member name="M:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode.EquivalentTo(System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates whether the syntax tree node is equivalent to given node.</summary> + <returns>true the syntax tree node is equivalent to given node; false.</returns> + <param name="node">The given node.</param> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode.IsBlock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether the syntax tree node is a block-level object.</summary> + <returns>true if the syntax tree node is a block-level object; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode.Length"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the length of the syntax tree node.</summary> + <returns>The length of the syntax tree node.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode.Parent"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the parent tree node of the current tree node.</summary> + <returns>The parent tree node of the current tree node.</returns> + </member> + <member name="P:System.Web.Razor.Parser.SyntaxTree.SyntaxTreeNode.Start"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the specific source location for the syntax tree node.</summary> + <returns>The specific source location for the syntax tree node.</returns> + </member> + <member name="T:System.Web.Razor.Text.BufferingTextReader"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Provides a lookahead buffer for the text reader.</summary> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.#ctor(System.IO.TextReader)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.BufferingTextReader" /> class.</summary> + <param name="source">The text reader for the buffer.</param> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.BeginLookahead"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Begins the lookahead buffering operation for this <see cref="T:System.Web.Razor.Text.BufferingTextReader" />.</summary> + <returns>A disposable action that ends the lookahead buffering.</returns> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.CancelBacktrack"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Discards the backtrack context associated the lookahead buffering operation.</summary> + </member> + <member name="P:System.Web.Razor.Text.BufferingTextReader.CurrentCharacter"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets the current character in the buffer.</summary> + <returns>The current character in the buffer.</returns> + </member> + <member name="P:System.Web.Razor.Text.BufferingTextReader.CurrentLocation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Gets or sets the current location of the character in the buffer.</summary> + <returns>The current location of the character in the buffer.</returns> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.Dispose(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Releases the unmanaged resources used by the current instance of this class, and optionally releases the managed resources.</summary> + <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.ExpandBuffer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Reads the next character from the text reader and appends it to the lookahead buffer.</summary> + <returns>true if a character was read from the text reader; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.NextCharacter"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Advances the buffer position to the next character.</summary> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.Peek"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the current character in the buffer.</summary> + <returns>The current character in the buffer.</returns> + </member> + <member name="M:System.Web.Razor.Text.BufferingTextReader.Read"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code. Returns the current character from the buffer and advances the buffer position to the next character.</summary> + <returns>The current character from the buffer.</returns> + </member> + <member name="T:System.Web.Razor.Text.ITextBuffer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.Text.ITextBuffer.Length"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.Text.ITextBuffer.Peek"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.Text.ITextBuffer.Position"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.Text.ITextBuffer.Read"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Text.ITextDocument"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.Text.ITextDocument.Location"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Text.LocationTagged`1"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a location tagged.</summary> + <typeparam name="T">The type of the location tagged.</typeparam> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.#ctor(`0,System.Int32,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.LocationTagged`1" /> class.</summary> + <param name="value">The value of the source.</param> + <param name="offset">The offset.</param> + <param name="line">The line.</param> + <param name="col">The column location of the source.</param> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.#ctor(`0,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.LocationTagged`1" /> class.</summary> + <param name="value">The value of the source.</param> + <param name="location">The location of the source.</param> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for the current instance.</summary> + <returns>The hash code for the current instance.</returns> + </member> + <member name="P:System.Web.Razor.Text.LocationTagged`1.Location"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the location of the source.</summary> + <returns>The location of the source.</returns> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.op_Equality(System.Web.Razor.Text.LocationTagged{`0},System.Web.Razor.Text.LocationTagged{`0})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two <see cref="T:System.Web.Razor.Text.LocationTagged{`0}" /> object are equal.</summary> + <returns>true if the two object are equal; otherwise, false.</returns> + <param name="left">The first object to compare.</param> + <param name="right">The second object to compare.</param> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.op_Implicit(System.Web.Razor.Text.LocationTagged{`0})~`0"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Converts the specified value to a <see cref="T:System.Web.Razor.Text.LocationTagged`1" /> object.</summary> + <returns>true if successfully converted; otherwise, false.</returns> + <param name="value">The value to convert.</param> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.op_Inequality(System.Web.Razor.Text.LocationTagged{`0},System.Web.Razor.Text.LocationTagged{`0})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two <see cref="T:System.Web.Razor.Text.LocationTagged{`0}" /> object are not equal.</summary> + <returns>true if the two object are not equal; otherwise, false.</returns> + <param name="left">The first object to compare.</param> + <param name="right">The second objet to compare.</param> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of the current instance.</summary> + <returns>The string that represents the current instance.</returns> + </member> + <member name="M:System.Web.Razor.Text.LocationTagged`1.ToString(System.String,System.IFormatProvider)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of the current instance.</summary> + <returns>A string that represents the current instance.</returns> + <param name="format">The format.</param> + <param name="formatProvider">The format provider.</param> + </member> + <member name="P:System.Web.Razor.Text.LocationTagged`1.Value"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the value of the source.</summary> + <returns>The value of the source.</returns> + </member> + <member name="T:System.Web.Razor.Text.LookaheadTextReader"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.Text.LookaheadTextReader.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.Text.LookaheadTextReader.BeginLookahead"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.Text.LookaheadTextReader.CancelBacktrack"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="P:System.Web.Razor.Text.LookaheadTextReader.CurrentLocation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Text.LookaheadToken"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the token to look for the razor.</summary> + </member> + <member name="M:System.Web.Razor.Text.LookaheadToken.#ctor(System.Action)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.LookaheadToken" /> class.</summary> + <param name="cancelAction">The action to cancel.</param> + </member> + <member name="M:System.Web.Razor.Text.LookaheadToken.Accept"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the token.</summary> + </member> + <member name="M:System.Web.Razor.Text.LookaheadToken.Dispose"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Releases the resources used by the current instance of the <see cref="T:System.Web.Razor.Text.LookaheadToken" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Text.LookaheadToken.Dispose(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Releases the unmanaged resources used by the <see cref="T:System.Web.Razor.Text.LookaheadToken" /> and optionally releases the managed resources.</summary> + <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> + </member> + <member name="T:System.Web.Razor.Text.SeekableTextReader"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a reader </summary> + </member> + <member name="M:System.Web.Razor.Text.SeekableTextReader.#ctor(System.IO.TextReader)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.SeekableTextReader" /> class.</summary> + <param name="source">The source reader.</param> + </member> + <member name="M:System.Web.Razor.Text.SeekableTextReader.#ctor(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.SeekableTextReader" /> class.</summary> + <param name="content">The string content.</param> + </member> + <member name="M:System.Web.Razor.Text.SeekableTextReader.#ctor(System.Web.Razor.Text.ITextBuffer)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.SeekableTextReader" /> class.</summary> + <param name="buffer">The text buffering.</param> + </member> + <member name="P:System.Web.Razor.Text.SeekableTextReader.Length"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the length of the text to read.</summary> + <returns>The length of the text to read.</returns> + </member> + <member name="P:System.Web.Razor.Text.SeekableTextReader.Location"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the source of location for the text reader.</summary> + <returns>The source of location for the text reader.</returns> + </member> + <member name="M:System.Web.Razor.Text.SeekableTextReader.Peek"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Reads the next character without changing the state of the reader or the character source.</summary> + <returns>An integer representing the next character to be read.</returns> + </member> + <member name="P:System.Web.Razor.Text.SeekableTextReader.Position"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the position to seek the text reader.</summary> + <returns>The position to seek the text reader.</returns> + </member> + <member name="M:System.Web.Razor.Text.SeekableTextReader.Read"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Reads the next character from the text reader and advances the character position by one character.</summary> + <returns>The next character from the text reader, or -1 if no more characters are available.</returns> + </member> + <member name="T:System.Web.Razor.Text.SourceLocation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a source location.</summary> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.#ctor(System.Int32,System.Int32,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.SourceLocation" /> class.</summary> + <param name="absoluteIndex">The absolute index.</param> + <param name="lineIndex">The line index.</param> + <param name="characterIndex">The character index.</param> + </member> + <member name="P:System.Web.Razor.Text.SourceLocation.AbsoluteIndex"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the absolute index for the source location.</summary> + <returns>The absolute index for the source location.</returns> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.Add(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Adds the two <see cref="T:System.Web.Razor.Text.SourceLocation" /> object.</summary> + <returns>The sum of the two <see cref="T:System.Web.Razor.Text.SourceLocation" /> object.</returns> + <param name="left">The first object to add.</param> + <param name="right">The second object to add.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.Advance(System.Web.Razor.Text.SourceLocation,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Advances the specified object to the given location.</summary> + <returns>The source location.</returns> + <param name="left">The location where to advance the object.</param> + <param name="text">The text that advances to the given location.</param> + </member> + <member name="P:System.Web.Razor.Text.SourceLocation.CharacterIndex"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the character index for the source location.</summary> + <returns>The character index for the source location.</returns> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.CompareTo(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Compares current object to the other object.</summary> + <returns>The value of the objects compared.</returns> + <param name="other">The object to compare.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.Equals(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the current <see cref="T:System.Web.Razor.Text.SourceLocation" /> object is equal to the other <see cref="T:System.Web.Razor.Text.SourceLocation" /> object.</summary> + <returns>true if the current object is equal to the other object; otherwise, false.</returns> + <param name="other">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>The hash code for this instance.</returns> + </member> + <member name="P:System.Web.Razor.Text.SourceLocation.LineIndex"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the line index for the source location.</summary> + <returns>The line index for the source location.</returns> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.op_Addition(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Adds the two <see cref="T:System.Web.Razor.Text.SourceLocation" /> object.</summary> + <returns>The <see cref="T:System.Web.Razor.Text.SourceLocation" /> that is the sum of the two object.</returns> + <param name="left">The object to add.</param> + <param name="right">The object to add.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.op_Equality(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two objects are equal.</summary> + <returns>true if the two objects are equal; otherwise, false.</returns> + <param name="left">The first object to compare.</param> + <param name="right">The second object to compare.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.op_GreaterThan(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the first object is greater than the second object.</summary> + <returns>true if the first object is greater than the second object; otherwise, false.</returns> + <param name="left">The first object.</param> + <param name="right">The second object.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.op_Inequality(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two <see cref="T:System.Web.Razor.Text.SourceLocation" />object are not equal.</summary> + <returns>true if the two objects are not equal; otherwise, false.</returns> + <param name="left">The object to compare.</param> + <param name="right">The object to compare.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.op_LessThan(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the first object is less than the second object.</summary> + <returns>true if the first object is greater than the second object; otherwise, false.</returns> + <param name="left">The first object.</param> + <param name="right">The second object.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.op_Subtraction(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <returns>Returns <see cref="T:System.Web.Razor.Text.SourceLocation" />.</returns> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.Subtract(System.Web.Razor.Text.SourceLocation,System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Subtracts the first object to the second object.</summary> + <returns>The difference of the two objects.</returns> + <param name="left">The first object.</param> + <param name="right">The second object.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocation.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of the source location.</summary> + <returns>A string representation of the source location.</returns> + </member> + <member name="F:System.Web.Razor.Text.SourceLocation.Undefined"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Text.SourceLocation.Zero"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Text.SourceLocationTracker"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Provides a source location tracker.</summary> + </member> + <member name="M:System.Web.Razor.Text.SourceLocationTracker.#ctor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.SourceLocationTracker" /> class.</summary> + </member> + <member name="M:System.Web.Razor.Text.SourceLocationTracker.#ctor(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.SourceLocationTracker" /> class.</summary> + <param name="currentLocation">The current location of the source.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocationTracker.CalculateNewLocation(System.Web.Razor.Text.SourceLocation,System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Calculates the new location of the source.</summary> + <returns>The new source location.</returns> + <param name="lastPosition">The last position.</param> + <param name="newContent">The new content.</param> + </member> + <member name="P:System.Web.Razor.Text.SourceLocationTracker.CurrentLocation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the current location of the source.</summary> + <returns>The current location of the source.</returns> + </member> + <member name="M:System.Web.Razor.Text.SourceLocationTracker.UpdateLocation(System.Char,System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Updates the source location.</summary> + <param name="characterRead">The character to read.</param> + <param name="nextCharacter">The character to update.</param> + </member> + <member name="M:System.Web.Razor.Text.SourceLocationTracker.UpdateLocation(System.String)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Updates the location of the source.</summary> + <returns>The <see cref="T:System.Web.Razor.Text.SourceLocationTracker" /> object.</returns> + <param name="content">The content of the source.</param> + </member> + <member name="T:System.Web.Razor.Text.TextBufferReader"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Provides a reader for text buffer.</summary> + </member> + <member name="M:System.Web.Razor.Text.TextBufferReader.#ctor(System.Web.Razor.Text.ITextBuffer)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.TextBufferReader" /> class.</summary> + <param name="buffer">The text buffer to read.</param> + </member> + <member name="M:System.Web.Razor.Text.TextBufferReader.BeginLookahead"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Begins reading the current text buffer.</summary> + <returns>An <see cref="T:System.IDisposable" /> instance that stops the text buffer.</returns> + </member> + <member name="M:System.Web.Razor.Text.TextBufferReader.CancelBacktrack"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Cancels backtrack.</summary> + </member> + <member name="P:System.Web.Razor.Text.TextBufferReader.CurrentLocation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current location of the text buffer.</summary> + <returns>The current location of the text buffer.</returns> + </member> + <member name="M:System.Web.Razor.Text.TextBufferReader.Dispose(System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Releases the unmanaged resources used by the <see cref="T:System.Web.Razor.Text.TextBufferReader" /> class and optionally releases the managed resources.</summary> + <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> + </member> + <member name="M:System.Web.Razor.Text.TextBufferReader.Peek"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the next text buffer to read.</summary> + <returns>The next text buffer to read.</returns> + </member> + <member name="M:System.Web.Razor.Text.TextBufferReader.Read"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Reads the current text buffer.</summary> + <returns>The current text buffer.</returns> + </member> + <member name="T:System.Web.Razor.Text.TextChange"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Describes a text change operation.</summary> + </member> + <member name="M:System.Web.Razor.Text.TextChange.#ctor(System.Int32,System.Int32,System.Web.Razor.Text.ITextBuffer,System.Int32,System.Int32,System.Web.Razor.Text.ITextBuffer)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.TextChange" /> class.</summary> + <param name="oldPosition">The position of the text change in the snapshot immediately before the change.</param> + <param name="oldLength">The length of the old text.</param> + <param name="oldBuffer">An old text buffer.</param> + <param name="newPosition">The position of the text change in the snapshot immediately after the change.</param> + <param name="newLength">The length of the new text.</param> + <param name="newBuffer">A new text buffer.</param> + </member> + <member name="M:System.Web.Razor.Text.TextChange.ApplyChange(System.String,System.Int32)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Applies the specified text change.</summary> + <returns>A string that contains the value of the text.</returns> + <param name="content">The content of the text.</param> + <param name="changeOffset">The change offset.</param> + </member> + <member name="M:System.Web.Razor.Text.TextChange.ApplyChange(System.Web.Razor.Parser.SyntaxTree.Span)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Applies the specified text change.</summary> + <returns>A string that contains the value of the text.</returns> + <param name="span">The span of the text change.</param> + </member> + <member name="M:System.Web.Razor.Text.TextChange.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="M:System.Web.Razor.Text.TextChange.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the hash code for this text change.</summary> + <returns>The hash code for this text change.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.IsDelete"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether this text change is a delete.</summary> + <returns>true if this text change is a delete; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.IsInsert"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether this text change is an insert.</summary> + <returns>true if this text change is an insert; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.IsReplace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether this text change is a replace.</summary> + <returns>true if this text change is a replace; otherwise, false.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.NewBuffer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a new text buffer.</summary> + <returns>A new text buffer.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.NewLength"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the length of the new text.</summary> + <returns>The length of the new text.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.NewPosition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the position of the text change in the snapshot immediately after the change.</summary> + <returns>The position of the text change in the snapshot immediately after the change.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.NewText"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the text that replaced the old text.</summary> + <returns>The text that replaced the old text.</returns> + </member> + <member name="M:System.Web.Razor.Text.TextChange.Normalize"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a normalized value of this text change.</summary> + <returns>A normalized value of this text change.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.OldBuffer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets an old text buffer.</summary> + <returns>An old text buffer.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.OldLength"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the length of the old text.</summary> + <returns>The length of the old text.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.OldPosition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the position of the text change in the snapshot immediately before the change.</summary> + <returns>The position of the text change in the snapshot immediately before the change.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextChange.OldText"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the text that was replaced.</summary> + <returns>The text that was replaced.</returns> + </member> + <member name="M:System.Web.Razor.Text.TextChange.op_Equality(System.Web.Razor.Text.TextChange,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two text change are equal.</summary> + <returns>true if the two text change are equal; otherwise, false.</returns> + <param name="left">The left text change.</param> + <param name="right">The right text change.</param> + </member> + <member name="M:System.Web.Razor.Text.TextChange.op_Inequality(System.Web.Razor.Text.TextChange,System.Web.Razor.Text.TextChange)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the two text change are not equal.</summary> + <returns>true if the two text change are not equal; otherwise, false.</returns> + <param name="left">The left text change.</param> + <param name="right">The right text change.</param> + </member> + <member name="M:System.Web.Razor.Text.TextChange.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a string representation of the text change.</summary> + <returns>A string representation of the text change.</returns> + </member> + <member name="T:System.Web.Razor.Text.TextChangeType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Text.TextChangeType.Insert"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Text.TextChangeType.Remove"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Text.TextDocumentReader"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Provides reader for text document.</summary> + </member> + <member name="M:System.Web.Razor.Text.TextDocumentReader.#ctor(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Text.TextDocumentReader" /> class.</summary> + <param name="source">The source to read.</param> + </member> + <member name="P:System.Web.Razor.Text.TextDocumentReader.Length"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the length of the document.</summary> + <returns>The length of the document.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextDocumentReader.Location"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the location of the document.</summary> + <returns>The location of the document.</returns> + </member> + <member name="M:System.Web.Razor.Text.TextDocumentReader.Peek"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the next text document to read.</summary> + <returns>The next text document to read.</returns> + </member> + <member name="P:System.Web.Razor.Text.TextDocumentReader.Position"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the position of the text document.</summary> + <returns>The position of the text document.</returns> + </member> + <member name="M:System.Web.Razor.Text.TextDocumentReader.Read"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Reads a specified text document.</summary> + <returns>The text document.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.CSharpHelpers"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Provides helper functions for the CSharp tokenizer.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.CSharpHelpers.IsIdentifierPart(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified character can be used for identifier.</summary> + <returns>true if the specified character can be used for identifier; otherwise, false.</returns> + <param name="character">The character to check.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.CSharpHelpers.IsIdentifierStart(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified character can be used as an identifier start character.</summary> + <returns>true if the specified character can be used as an identifier start character; otherwise, false.</returns> + <param name="character">The character to check.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.CSharpHelpers.IsRealLiteralSuffix(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified character is a literal suffix for real numbers.</summary> + <returns>true if the specified character is a literal suffix for real numbers; otherwise, false.</returns> + <param name="character">The character to check.</param> + </member> + <member name="T:System.Web.Razor.Tokenizer.CSharpTokenizer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a CSharp tokenizer.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.CSharpTokenizer.#ctor(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.CSharpTokenizer" /> class.</summary> + <param name="source">The source.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.CSharpTokenizer.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a CSharp tokenizer symbol.</summary> + <returns>A CSharp tokenizer symbol.</returns> + <param name="start">The beginning of the source location.</param> + <param name="content">The contents.</param> + <param name="type">The CSharp symbol type.</param> + <param name="errors">A collection of razor errors.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.CSharpTokenizer.RazorCommentStarType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the star type of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType" />.</summary> + <returns>The star type of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType" />.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.CSharpTokenizer.RazorCommentTransitionType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the razor comment transition type for the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType" />.</summary> + <returns>The razor comment transition type for the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType" />.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.CSharpTokenizer.RazorCommentType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the razor comment type for the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType" />.</summary> + <returns>The razor comment type for the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType" />.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.CSharpTokenizer.StartState"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the state of the machine.</summary> + <returns>The state of the machine.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.HtmlTokenizer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the html tokenizer of the razor.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.HtmlTokenizer.#ctor(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.HtmlTokenizer" /> class.</summary> + <param name="source">The source for the text document.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.HtmlTokenizer.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a symbol for the specified parameters of the html tokenizer.</summary> + <returns>A symbol to create for the specified parameters of the html tokenizer.</returns> + <param name="start">The source location.</param> + <param name="content">The content string.</param> + <param name="type">The type of html symbol.</param> + <param name="errors">The razor errors.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.HtmlTokenizer.RazorCommentStarType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the html symbols for the razor comment star type.</summary> + <returns>The html symbols for the razor comment star type.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.HtmlTokenizer.RazorCommentTransitionType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the html symbols for the razor comment transition type.</summary> + <returns>The html symbols for the razor comment transition type.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.HtmlTokenizer.RazorCommentType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the html symbols for the razor comment type.</summary> + <returns>The html symbols for the razor comment type.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.HtmlTokenizer.StartState"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the start of the state machine for the html.</summary> + <returns>The start of the state machine for the html.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.ITokenizer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.ITokenizer.NextSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Tokenizer.Tokenizer`2"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + <typeparam name="TSymbol">The type for the language symbol.</typeparam> + <typeparam name="TSymbolType">The enumeration type for the language symbol.</typeparam> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.#ctor(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Tokenizer`2" /> class.</summary> + <param name="source">The source.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.AfterRazorCommentTransition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns a result after the razor comment transition.</summary> + <returns>The result.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.At(System.String,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the lookahead buffer contains the expected string.</summary> + <returns>true if the lookahead buffer contains the expected string; otherwise, false.</returns> + <param name="expected">The string to check.</param> + <param name="caseSensitive">true to indicate comparison is case sensitive; otherwise, false.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.Buffer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the buffer for the tokenizer.</summary> + <returns>The buffer for the tokenizer.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.CharOrWhiteSpace(System.Char)"> + <summary>Returns a function delegate, that accepts a character parameter and returns a value that indicates whether the character parameter is equal to specified character or white space.</summary> + <returns>A function delegate.</returns> + <param name="character">The character used to compare.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,`1,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a language symbol type for the tokenizer with the specified content.</summary> + <returns>A language symbol type for the tokenizer.</returns> + <param name="start">The start of the source location.</param> + <param name="content">The content value.</param> + <param name="type">The symbol type.</param> + <param name="errors">The razor error.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.CurrentCharacter"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current character in the tokenizer.</summary> + <returns>The current character.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.CurrentErrors"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a list of the current razor errors.</summary> + <returns>A list of the current errors.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.CurrentLocation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current source location.</summary> + <returns>The current source location.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.CurrentStart"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current start of the source location.</summary> + <returns>The current start of the source location.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.EndOfFile"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value whether the tokenizer current location is at the end of the file.</summary> + <returns>true if the tokenizer current location is at the end of the file; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.EndSymbol(System.Web.Razor.Text.SourceLocation,`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the language end symbol type used by the tokenizer.</summary> + <returns>The language end symbol type.</returns> + <param name="start">The start of the source location.</param> + <param name="type">The enumeration type for the language symbol.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.EndSymbol(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the language end symbol type used by the tokenizer.</summary> + <returns>The language end symbol type.</returns> + <param name="type">The enumeration type for the language symbol.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.HaveContent"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value whether the tokenizer have content.</summary> + <returns>true if the tokenizer have content; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.MoveNext"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Reads to the next character from the code reader.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.NextSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Shows the next symbol to be used.</summary> + <returns>The next symbol to be used.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.Peek"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Reads the next symbol in the code.</summary> + <returns>The next symbol to read.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.RazorCommentBody"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Parses the Razor comment body.</summary> + <returns>The object that represent the state of the result.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.RazorCommentStarType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the star type for the razor comment.</summary> + <returns>The star type for the razor comment.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.RazorCommentTransitionType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the transition type for the razor comment.</summary> + <returns>The transition type for the razor comment.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.RazorCommentType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the type of razor comment.</summary> + <returns>The type of razor comment.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.Reset"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Sets the tokenizer status to its initial state.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.ResumeSymbol(`0)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Resumes using the previous language symbol type.</summary> + <param name="previous">The previous language symbol type.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.Single(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Uses a single type of symbol.</summary> + <returns>A single type of symbol.</returns> + <param name="type">The type of symbol.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Tokenizer`2.Source"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the source of the text document.</summary> + <returns>The source of the source document.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.StartSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the start symbol used in this class.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.System#Web#Razor#Tokenizer#ITokenizer#NextSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the next language symbol type.</summary> + <returns>The next language symbol type.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.TakeAll(System.String,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Takes the string if found in the lookahead buffer into the tokenizer buffer.</summary> + <returns>true if the lookahead buffer contains the expected string; otherwise, false.</returns> + <param name="expected">The string to match.</param> + <param name="caseSensitive">true to indicate comparison is case sensitive; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.TakeCurrent"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the current character into the buffer.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.TakeString(System.String,System.Boolean)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Accepts the given input string into the buffer.</summary> + <returns>true if the whole input string was accepted; false, if only a substring was accepted.</returns> + <param name="input">The input string.</param> + <param name="caseSensitive">true to indicate comparison is case sensitive; otherwise, false.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Tokenizer`2.TakeUntil(System.Func{System.Char,System.Boolean})"> + <summary>Parses the source document until the condition specified by predicate is met or end file is reached.</summary> + <returns>true if the predicate condition is met; false if end of file is reached.</returns> + <param name="predicate">The predicate that specifies the processing condition.</param> + </member> + <member name="T:System.Web.Razor.Tokenizer.TokenizerView`3"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the specified parameters for the tokenizer view.</summary> + <typeparam name="TTokenizer">The type tokenizer.</typeparam> + <typeparam name="TSymbol">The type symbol.</typeparam> + <typeparam name="TSymbolType">The token symbol type.</typeparam> + </member> + <member name="M:System.Web.Razor.Tokenizer.TokenizerView`3.#ctor(`0)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.TokenizerView`3" /> class.</summary> + <param name="tokenizer">The tokenizer view.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.TokenizerView`3.Current"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the current view of the TSymbol.</summary> + <returns>The current view of the TSymbol.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.TokenizerView`3.EndOfFile"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a value that indicates whether the view can reach the end of a file.</summary> + <returns>true if the view can reach the end of a file; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.TokenizerView`3.Next"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the tokenizer moves to the next view.</summary> + <returns>true if the tokenizer moves to the next view; false.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.TokenizerView`3.PutBack(`1)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Puts a specified symbol into the tokenizer view.</summary> + <param name="symbol">The symbol.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.TokenizerView`3.Source"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the source of the text document for the tokenizer view.</summary> + <returns>The source of the text document for the tokenizer view.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.TokenizerView`3.Tokenizer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the tokenizer to view the symbols for the razor.</summary> + <returns>The tokenizer to view the symbols for the razor.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.VBHelpers"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a set of characters as helpers in VB.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.VBHelpers.IsDoubleQuote(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a value whether a specified character is enclosed in double quotation marks (").</summary> + <returns>true if the character is enclosed in double quotation marks ("); otherwise, false.</returns> + <param name="character">The character.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.VBHelpers.IsOctalDigit(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a value whether a character is in octal digit.</summary> + <returns>true if a character is in octal digit; otherwise, false.</returns> + <param name="character">The character.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.VBHelpers.IsSingleQuote(System.Char)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a value whether a specified character is enclosed in a single quotation mark (').</summary> + <returns>true if the character is enclosed in a single quotation mark ('); otherwise, false.</returns> + <param name="character">The character.</param> + </member> + <member name="T:System.Web.Razor.Tokenizer.VBTokenizer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Allows an application to break a VB symbol into tokens.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.VBTokenizer.#ctor(System.Web.Razor.Text.ITextDocument)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.VBTokenizer" /> class.</summary> + <param name="source">The source of text.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.VBTokenizer.CreateSymbol(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.VBSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Creates a domain of symbols.</summary> + <returns>A domain of symbols.</returns> + <param name="start">The source location.</param> + <param name="content">The content value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</param> + <param name="errors">The razor error.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.VBTokenizer.RazorCommentStarType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the VB symbol type.</summary> + <returns>The VB symbol type.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.VBTokenizer.RazorCommentTransitionType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the transition style of the VB symbol.</summary> + <returns>The transition style of the VB symbol.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.VBTokenizer.RazorCommentType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the razor type comment of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</summary> + <returns>The razor type comment of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.VBTokenizer.StartState"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the start state of the machine.</summary> + <returns>The start state of the machine.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Abstract"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.As"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Base"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Bool"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Break"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Byte"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Case"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Catch"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Char"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Checked"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Class"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Const"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Continue"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Decimal"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Default"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Delegate"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Do"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Double"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Else"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Enum"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Event"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Explicit"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Extern"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.False"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Finally"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Fixed"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Float"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.For"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Foreach"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Goto"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.If"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Implicit"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.In"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Int"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Interface"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Internal"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Is"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Lock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Long"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Namespace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.New"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Null"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Object"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Operator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Out"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Override"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Params"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Private"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Protected"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Public"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Readonly"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Ref"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Return"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Sbyte"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Sealed"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Short"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Sizeof"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Stackalloc"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Static"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.String"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Struct"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Switch"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.This"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Throw"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.True"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Try"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Typeof"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Uint"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Ulong"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Unchecked"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Unsafe"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Ushort"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Using"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Virtual"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Void"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.Volatile"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.While"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a C sharp symbol for the razor tokenizer.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.#ctor(System.Int32,System.Int32,System.Int32,System.String,System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol" /> class.</summary> + <param name="offset">The symbol’s offset.</param> + <param name="line">The line.</param> + <param name="column">The column</param> + <param name="content">The content of the symbol.</param> + <param name="type">The type of the symbol.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.#ctor(System.Int32,System.Int32,System.Int32,System.String,System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol" /> class.</summary> + <param name="offset">The symbol’s offset.</param> + <param name="line">The line.</param> + <param name="column">The column</param> + <param name="content">The content of the symbol.</param> + <param name="type">The type of the symbol.</param> + <param name="errors">A list of errors.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.#ctor(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol" /> class.</summary> + <param name="start">The location to start the symbol.</param> + <param name="content">The content of the symbol.</param> + <param name="type">The type of the symbol.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.#ctor(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol" /> class.</summary> + <param name="start">The location to start the symbol.</param> + <param name="content">The content of the symbol.</param> + <param name="type">The type of the symbol.</param> + <param name="errors">A list of errors.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified object is equal to the current object.</summary> + <returns>true if the specified object is equal to the current object; otherwise, false.</returns> + <param name="obj">The object to compare to.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.EscapedIdentifier"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets a value that indicates whether the symbol has an escaped identifier.</summary> + <returns>true if the symbol has an escaped identifier; otherwise, false.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this current instance.</summary> + <returns>The hash code for this current instance.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.CSharpSymbol.Keyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the language keyword.</summary> + <returns>The language keyword.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.And"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.AndAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Arrow"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Assign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.CharacterLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Colon"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Comma"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Comment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Decrement"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.DivideAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Dot"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.DoubleAnd"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.DoubleColon"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.DoubleOr"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Equals"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.GreaterThan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.GreaterThanEqual"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Hash"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Identifier"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Increment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.IntegerLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Keyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.LeftBrace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.LeftBracket"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.LeftParenthesis"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.LeftShift"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.LeftShiftAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.LessThan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.LessThanEqual"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Minus"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.MinusAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Modulo"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.ModuloAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.MultiplyAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.NewLine"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Not"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.NotEqual"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.NullCoalesce"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Or"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.OrAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Plus"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.PlusAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.QuestionMark"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RazorCommentStar"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RazorCommentTransition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RealLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RightBrace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RightBracket"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RightParenthesis"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RightShift"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.RightShiftAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Semicolon"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Slash"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Star"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.StringLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Tilde"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Transition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Unknown"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.WhiteSpace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.Xor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.CSharpSymbolType.XorAssign"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the Html symbols.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol.#ctor(System.Int32,System.Int32,System.Int32,System.String,System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol" /> class.</summary> + <param name="offset">The location of the symbol.</param> + <param name="line">The exact line the symbol is found.</param> + <param name="column">The column number the symbol is found.</param> + <param name="content">The content value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType" />.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol.#ctor(System.Int32,System.Int32,System.Int32,System.String,System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol" /> class.</summary> + <param name="offset">The location of the symbol.</param> + <param name="line">The exact line the symbol is found.</param> + <param name="column">The column number the symbol is found.</param> + <param name="content">The content value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType" />.</param> + <param name="errors">The razor error.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol.#ctor(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol" /> class.</summary> + <param name="start">The start of the source location.</param> + <param name="content">The content value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType" />.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol.#ctor(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbol" /> class.</summary> + <param name="start">The start of the source location.</param> + <param name="content">The content value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType" />.</param> + <param name="errors">The razor error.</param> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.Bang"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.CloseAngle"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.Colon"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.DoubleHyphen"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.DoubleQuote"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.Equals"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.LeftBracket"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.NewLine"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.OpenAngle"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.QuestionMark"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.RazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.RazorCommentStar"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.RazorCommentTransition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.RightBracket"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.SingleQuote"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.Solidus"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.Text"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.Transition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.Unknown"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.HtmlSymbolType.WhiteSpace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.ISymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents an interface for the web razor symbol.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.ISymbol.ChangeStart(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Changes the location of the symbol.</summary> + <param name="newStart">The new location of the symbol.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.ISymbol.Content"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the content of the symbol.</summary> + <returns>The content of the symbol.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.ISymbol.OffsetStart(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates the starting offset of the symbol.</summary> + <param name="documentStart">The location where to start the document.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.ISymbol.Start"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the location of the symbol.</summary> + <returns>The location of the symbol.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.CommentBody"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.CommentStar"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.CommentStart"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.Identifier"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.Keyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.NewLine"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.Transition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.Unknown"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.KnownSymbolType.WhiteSpace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents a new instance of symbols.</summary> + <typeparam name="TType">The generic type.</typeparam> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.#ctor(System.Web.Razor.Text.SourceLocation,System.String,`0,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1" /> class.</summary> + <param name="start">The source location.</param> + <param name="content">The content value.</param> + <param name="type">The type.</param> + <param name="errors">The razor error.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.ChangeStart(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Changes the start of the machine.</summary> + <param name="newStart">The new start.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.Content"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the content of a <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1" />.</summary> + <returns>The content of a <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1" />.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Determines whether the specified Object is equal to the current Object.</summary> + <returns>true if the specified Object is equal to the current Object; otherwise, false.</returns> + <param name="obj">The object.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.Errors"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the razor error.</summary> + <returns>The razor error.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Retrieves a hash code based on the current <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1" /> object.</summary> + <returns>A hash of the current <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1" /> object.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.OffsetStart(System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Starts the time’s offset for the source location.</summary> + <param name="documentStart">The document start.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.Start"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the starting point of the source location.</summary> + <returns>The starting point of the source location.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.ToString"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Generates a string representation of the current <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1" /> object.</summary> + <returns>A string representation of the current <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1" /> object.</returns> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.SymbolBase`1.Type"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets a Type that inherits from the base Type.</summary> + <returns>A Type that inherits from the base Type.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the symbol extensions for the web tokenizer.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions.GetContent(System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol},System.Web.Razor.Text.SourceLocation)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</summary> + <returns>The content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</returns> + <param name="symbols">The symbols to provide.</param> + <param name="spanStart">The starting index of the span.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions.GetContent(System.Web.Razor.Parser.SyntaxTree.SpanBuilder)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</summary> + <returns>The content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</returns> + <param name="span">The intersection with the given span.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions.GetContent(System.Web.Razor.Parser.SyntaxTree.SpanBuilder,System.Func{System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol},System.Collections.Generic.IEnumerable{System.Web.Razor.Tokenizer.Symbols.ISymbol}})"> + <summary>Gets the content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</summary> + <returns>The content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</returns> + <param name="span">The intersection with the given span.</param> + <param name="filter">A list of chosen symbols.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions.GetContent(System.Web.Razor.Tokenizer.Symbols.ISymbol)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</summary> + <returns>The content of this <see cref="T:System.Web.Razor.Tokenizer.Symbols.SymbolExtensions" /> class.</returns> + <param name="symbol">The provided symbols.</param> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.VBKeyword"> + <summary>Enumerates the list of Visual Basic keywords.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.AddHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.AddressOf"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Alias"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.And"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.AndAlso"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.As"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Boolean"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.ByRef"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Byte"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.ByVal"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Call"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Case"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Catch"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CBool"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CByte"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CChar"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CDate"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CDbl"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CDec"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Char"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CInt"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Class"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CLng"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CObj"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Const"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Continue"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CSByte"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CShort"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CSng"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CStr"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CUInt"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CULng"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.CUShort"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Date"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Decimal"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Declare"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Default"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Delegate"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Dim"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.DirectCast"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Do"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Double"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Each"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Else"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.ElseIf"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.End"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.EndIf"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Enum"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Erase"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Error"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Event"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Exit"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.False"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Finally"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.For"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Friend"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Function"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Get"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.GetType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.GetXmlNamespace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Global"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.GoSub"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.GoTo"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Handles"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.If"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Implements"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Imports"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.In"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Inherits"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Integer"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Interface"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Is"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.IsNot"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Let"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Lib"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Like"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Long"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Loop"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Me"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Mod"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Module"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.MustInherit"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.MustOverride"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.MyBase"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.MyClass"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Namespace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Narrowing"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.New"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Next"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Not"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Nothing"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.NotInheritable"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.NotOverridable"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Object"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Of"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.On"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Operator"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Option"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Optional"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Or"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.OrElse"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Overloads"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Overridable"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Overrides"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.ParamArray"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Partial"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Private"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Property"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Protected"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Public"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.RaiseEvent"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.ReadOnly"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.ReDim"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Rem"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.RemoveHandler"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Resume"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Return"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.SByte"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Select"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Set"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Shadows"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Shared"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Short"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Single"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Static"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Step"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Stop"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.String"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Structure"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Sub"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.SyncLock"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Then"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Throw"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.To"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.True"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Try"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.TryCast"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.TypeOf"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.UInteger"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.ULong"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.UShort"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Using"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Variant"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Wend"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.When"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.While"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Widening"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.With"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.WithEvents"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.WriteOnly"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBKeyword.Xor"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.VBSymbol"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Represents the VB symbol components.</summary> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.VBSymbol.#ctor(System.Int32,System.Int32,System.Int32,System.String,System.Web.Razor.Tokenizer.Symbols.VBSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbol" /> class.</summary> + <param name="offset">The offset value.</param> + <param name="line">The line value.</param> + <param name="column">The column value.</param> + <param name="content">The content String value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.VBSymbol.#ctor(System.Int32,System.Int32,System.Int32,System.String,System.Web.Razor.Tokenizer.Symbols.VBSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbol" /> class.</summary> + <param name="offset">The offset value.</param> + <param name="line">The line value.</param> + <param name="column">The column value.</param> + <param name="content">The content String value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</param> + <param name="errors">List of razor errors.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.VBSymbol.#ctor(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.VBSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbol" /> class.</summary> + <param name="start">The start of the source location.</param> + <param name="content">The content String value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.VBSymbol.#ctor(System.Web.Razor.Text.SourceLocation,System.String,System.Web.Razor.Tokenizer.Symbols.VBSymbolType,System.Collections.Generic.IEnumerable{System.Web.Razor.Parser.SyntaxTree.RazorError})"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Initializes a new instance of the <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbol" /> class.</summary> + <param name="start">The start of the source location.</param> + <param name="content">The content String value.</param> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</param> + <param name="errors">List of razor errors.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.VBSymbol.Equals(System.Object)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Indicates a value whether the current object is equal to the new object.</summary> + <returns>true if the current object is equal to the new object; otherwise, false.</returns> + <param name="obj">The object to compare.</param> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.VBSymbol.GetHashCode"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Returns the hash code for this instance.</summary> + <returns>The hash code to return.</returns> + </member> + <member name="M:System.Web.Razor.Tokenizer.Symbols.VBSymbol.GetSample(System.Web.Razor.Tokenizer.Symbols.VBSymbolType)"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets the specified data sample from the object.</summary> + <returns>The specified data sample from the object.</returns> + <param name="type">The <see cref="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType" />.</param> + </member> + <member name="P:System.Web.Razor.Tokenizer.Symbols.VBSymbol.Keyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.Gets or sets the keyword used in the VB.</summary> + <returns>The keyword used.</returns> + </member> + <member name="T:System.Web.Razor.Tokenizer.Symbols.VBSymbolType"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Add"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Bang"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.CharacterLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Colon"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Comma"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Comment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Concatenation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.DateLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Divide"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Dollar"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Dot"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Equal"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Exponentiation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.FloatingPointLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.GreaterThan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Hash"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Identifier"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.IntegerDivide"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.IntegerLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Keyword"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.LeftBrace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.LeftBracket"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.LeftParenthesis"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.LessThan"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.LineContinuation"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Multiply"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.NewLine"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.QuestionMark"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.RazorComment"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.RazorCommentStar"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.RazorCommentTransition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.RightBrace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.RightBracket"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.RightParenthesis"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.StringLiteral"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Subtract"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Transition"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.Unknown"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + <member name="F:System.Web.Razor.Tokenizer.Symbols.VBSymbolType.WhiteSpace"> + <summary>This type/member supports the .NET Framework infrastructure and is not intended to be used directly from your code.</summary> + </member> + </members> +</doc> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Moq.4.1.1309.1617/Moq.4.1.1309.1617.nuspec Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,163 @@ +<?xml version="1.0"?> +<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd"> + <metadata> + <id>Moq</id> + <version>4.1.1309.1617</version> + <title>Moq: an enjoyable mocking library</title> + <authors>Daniel Cazzulino</authors> + <owners>Daniel Cazzulino</owners> + <licenseUrl>http://www.opensource.org/licenses/bsd-license.php</licenseUrl> + <projectUrl>http://www.moqthis.com/</projectUrl> + <requireLicenseAcceptance>false</requireLicenseAcceptance> + <description>The most popular and friendly mocking framework for .NET</description> + <releaseNotes>Version 4.1 +* Added covariant IMock<out T> interface to Mock<T> +* Added It.IsNotNull<T> +* Fix: 'NullReferenceException when subscribing to an event' +* Added overloads to Verify to accept Times as a Method Group +* Feature request: It.IsIn(..), It.IsNotIn(...) +* Corrected Verify method behavior for generic methods calls +* Differentiate verification error from mock crash +* Fix: Adding (and removing) handlers for events declared on interfaces works +when CallBase = true. +* Update to latest Castle +* Fix: Mock.Of (Functional Syntax) doesn't work on properties with non-public setters +* Fix: Allow to use CallBase instead of Returns +* Fix: Solved Multi-threading issue - IndexOutOfRangeException +* Capability of mocking delegates (event handlers) + +Version 4.0 +* Linq to Mocks: Mock.Of<T>(x => x.Id == 23 && x.Title == "Rocks!") +* Fixed issues: + * 87 BadImageFormatException when using a mock with a Visual Studio generated Accessor object + * 166 Unable to use a delegate to mock a function that takes 5 or more parameters. + * 168 Call count failure message never says which is the actual invocation count + * 175 theMock.Object failing on VS2010 Beta 1 + * 177 Generic constraint on interface method causes BadImageFormatException when getting Object. + * 183 Display what invocations were recieved when the expected one hasn't been met + * 186 Methods that are not virtual gives non-sense-exception message + * 188 More Callback Overloads + * 199 Simplify SetupAllProperties implementation to simply iterate and call SetupProperty + * 200 Fluent mock does not honor parent mock CallBase setting. + * 202 Mock.Protected().Expect() deprecated with no work-around + * 204 Allow default return values to be specified (per-mock) + * 205 Error calling SetupAllProperties for Mock<IDataErrorInfo> + * 206 Linq-to-Mocks Never Returns on Implicit Boolean Property + * 207 NullReferenceException thrown when using Mocks.CreateQuery with implicit boolean expression + * 208 Can't setup a mock for method that accept lambda expression as argument. + * 211 SetupAllProperties should return the Mock<T> instead of void. + * 223 When a method is defined to make the setup an asserts mock fails + * 226 Can't raise events on mocked Interop interfaces + * 229 CallBase is not working for virtual events + * 238 Moq fails to mock events defined in F# + * 239 Use Func instead of Predicate + * 250 4.0 Beta 2 regression - cannot mock MethodInfo when targetting .NET 4 + * 251 When a generic interface also implements a non-generic version, Verify does not work in some cases + * 254 Unable to create mock of EnvDTE.DTE + * 261 Can not use protected setter in public property + * 267 Generic argument as dependency for method Setup overrides all previous method setups for a given method + * 273 Attempting to create a mock thrown a Type Load exception. The message refers to an inaccessible interface. + * 276 .Net 3.5 no more supported + +Version 3.0 + +* Silverlight support! Finally integrated Jason's Silverlight contribution! Issue #73 +* Brand-new simplified event raising syntax (#130): mock.Raise(foo => foo.MyEvent += null, new MyArgs(...)); +* Support for custom event signatures (not compatible with EventHandler): mock.Raise(foo => foo.MyEvent += null, arg1, arg2, arg3); +* Substantially improved property setter behavior: mock.VerifySet(foo => foo.Value = "foo"); //(also available for SetupSet +* Renamed Expect* with Setup* +* Vastly simplified custom argument matchers: public int IsOdd() < return Match<int>.Create(v => i % 2 == 0); > +* Added support for verifying how many times a member was invoked: mock.Verify(foo => foo.Do(), Times.Never()); +* Added simple sample app named StoreSample +* Moved Stub functionality to the core API (SetupProperty and SetupAllProperties) +* Fixed sample ASP.NET MVC app to work with latest version +* Allow custom matchers to be created with a substantially simpler API +* Fixed issue #145 which prevented discrimination of setups by generic method argument types +* Fixed issue #141 which prevented ref arguments matching value types (i.e. a Guid) +* Implemented improvement #131: Add support for It.IsAny and custom argument matchers for SetupSet/VerifySet +* Implemented improvement #124 to render better error messages +* Applied patch from David Kirkland for improvement #125 to improve matching of enumerable parameters +* Implemented improvement #122 to provide custom errors for Verify +* Implemented improvement #121 to provide null as default value for Nullable<T> +* Fixed issue #112 which fixes passing a null argument to a mock constructor +* Implemented improvement #111 to better support params arguments +* Fixed bug #105 about improperly overwriting setups for property getter and setter +* Applied patch from Ihar.Bury for issue #99 related to protected expectations +* Fixed issue #97 on not being able to use SetupSet/VerifySet if property did not have a getter +* Better integration with Pex (http://research.microsoft.com/en-us/projects/Pex/) +* Various other minor fixes (#134, #135, #137, #138, #140, etc.) + + +Version 2.6 + +* Implemented Issue #55: We now provide a mock.DefaultValue = [DefaultValue.Empty | DefaultValue.Mock] which will provide the current behavior (default) or mocks for mockeable return types for loose mock invocations without expectations. +* Added support for stubbing properties from moq-contrib: now you can do mock.Stub(m => m.Value) and add stub behavior to the property. mock.StubAll() is also provided. This integrates with the DefaultValue behavior too, so you can stub entire hierarchies :). +* Added support for mocking methods with out and ref parameters (Issue #50) +* Applied patch contributed by slava for Issue #72: add support to limit numbor of calls on mocked method (we now have mock.Expect(...).AtMost(5)) +* Implemented Issue #94: Easier setter verification: Now we support ExpectSet(m = m.Value, "foo") and VerifySet(m = m.Value, 5) (Thanks ASP.NET MVC Team!) +* Implemented issue #96: Automatically chain mocks when setting expectations. It's now possible to specify expectations for an entire hierarchy of objects just starting from the root mock. THIS IS REALLY COOL!!! +* Fixed Issue #89: Expects() does not always return last expectation +* Implemented Issue 91: Expect a method/property to never be called (added Never() method to an expectation. Can be used on methods, property getters and setters) +* Fixed Issue 86: IsAny<T> should check if the value is actually of type T +* Fixed Issue 88: Cannot mock protected internal virtual methods using Moq.Protected +* Fixed Issue 90: Removing event handlers from mocked objects +* Updated demo and added one more test for the dynamic addition of interfaces + +Version 2.5 + +* Added support for mocking protected members +* Added new way of extending argument matchers which is now very straightforward +* Added support for mocking events +* Added support for firing events from expectations +* Removed usage of MBROs which caused inconsistencies in mocking features +* Added ExpectGet and ExpectSet to better support properties, and provide better intellisense. +* Added verification with expressions, which better supports Arrange-Act-Assert testing model (can do Verify(m => m.Do(...))) +* Added Throws<TException> +* Added mock.CallBase property to specify whether the virtual members base implementation should be called +* Added support for implementing and setting expectations and verifying additional interfaces in the mock, via the new mock.As<TInterface>() method (thanks Fernando Simonazzi!) +* Improved argument type matching for Is/IsAny (thanks Jeremy.Skinner!) + + +Version 2.0 + +* Refactored fluent API on mocks. This may cause some existing tests to fail, but the fix is trivial (just reorder the calls to Callback, Returns and Verifiable) +* Added support for retrieving a Mock<T> from a T instance created by a mock. +* Added support for retrieving the invocation arguments from a Callback or Returns. +* Implemented AtMostOnce() constraint +* Added support for creating MBROs with protected constructors +* Loose mocks now return default empty arrays and IEnumerables instead of nulls + + +Version 1.5.1 + +* Refactored MockFactory to make it simpler and more explicit to use with regards to verification. Thanks Garry Shutler for the feedback! + +Version 1.5 + +* Added MockFactory to allow easy construction of multiple mocks with the same behavior and verification + +Version 1.4 + +* Added support for passing constructor arguments for mocked classes. +* Improved code documentation + +Version 1.3 + + * Added support for overriding expectations set previously on a Mock. Now adding a second expectation for the same method/property call will override the existing one. This facilitates setting up default expectations in a fixture setup and overriding when necessary in a specific test. + * Added support for mock verification. Both Verify and VerifyAll are provided for more flexibility (the former only verifies methods marked Verifiable) + +Version 1.2 + +* Added support for MockBehavior mock constructor argument to affect the way the mocks expect or throw on calls. + +Version 1.1 + +* Merged branch for dynamic types. Now Moq is based on Castle DynamicProxy2 to support a wider range of mock targets. +* Added ILMerge so that Castle libraries are merged into Moq assembly (no need for external references and avoid conflicts) + +Version 1.0 + +* Initial release, initial documentation process in place, etc.</releaseNotes> + <tags>tdd mocking mocks unittesting agile</tags> + </metadata> +</package> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Moq.4.1.1309.1617/lib/net35/Moq.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,6034 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>Moq</name> + </assembly> + <members> + <member name="T:Moq.Language.ISetupConditionResult`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.Setup(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + The expectation will be considered only in the former condition. + </summary> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.Setup``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + The expectation will be considered only in the former condition. + </summary> + <typeparam name="TResult"></typeparam> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Setups the get. + </summary> + <typeparam name="TProperty">The type of the property.</typeparam> + <param name="expression">The expression.</param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupSet``1(System.Action{`0})"> + <summary> + Setups the set. + </summary> + <typeparam name="TProperty">The type of the property.</typeparam> + <param name="setterExpression">The setter expression.</param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupSet(System.Action{`0})"> + <summary> + Setups the set. + </summary> + <param name="setterExpression">The setter expression.</param> + <returns></returns> + </member> + <member name="M:Moq.IInterceptStrategy.HandleIntercept(Moq.Proxy.ICallContext,Moq.InterceptStrategyContext)"> + <summary> + Handle interception + </summary> + <param name="invocation">the current invocation context</param> + <param name="ctx">shared data among the strategies during an interception</param> + <returns>true if further interception has to be processed, otherwise false</returns> + </member> + <member name="T:Moq.IMock`1"> + <summary> + Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> + are possible. Only covers the covariant members of Mock<T>. + </summary> + </member> + <member name="P:Moq.IMock`1.Object"> + <summary> + Exposes the mocked object instance. + </summary> + </member> + <member name="P:Moq.IMock`1.Behavior"> + <summary> + Behavior of the mock, according to the value set in the constructor. + </summary> + </member> + <member name="P:Moq.IMock`1.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.IMock`1.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="M:Moq.AddActualInvocation.GetEventFromName(System.String)"> + <summary> + Get an eventInfo for a given event name. Search type ancestors depth first if necessary. + </summary> + <param name="eventName">Name of the event, with the set_ or get_ prefix already removed</param> + </member> + <member name="M:Moq.AddActualInvocation.GetNonPublicEventFromName(System.String)"> + <summary> + Get an eventInfo for a given event name. Search type ancestors depth first if necessary. + Searches also in non public events. + </summary> + <param name="eventName">Name of the event, with the set_ or get_ prefix already removed</param> + </member> + <member name="M:Moq.AddActualInvocation.GetAncestorTypes(System.Type)"> + <summary> + Given a type return all of its ancestors, both types and interfaces. + </summary> + <param name="initialType">The type to find immediate ancestors of</param> + </member> + <member name="T:Moq.Language.ICallback"> + <summary> + Defines the <c>Callback</c> verb and overloads. + </summary> + </member> + <member name="T:Moq.IHideObjectMembers"> + <summary> + Helper interface used to hide the base <see cref="T:System.Object"/> + members from the fluent API to make it much cleaner + in Visual Studio intellisense. + </summary> + </member> + <member name="M:Moq.IHideObjectMembers.GetType"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.GetHashCode"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.ToString"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.Equals(System.Object)"> + <summary/> + </member> + <member name="M:Moq.Language.ICallback.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the method is called. + </summary> + <param name="action">The callback method to invoke.</param> + <example> + The following example specifies a callback to set a boolean + value that can be used later: + <code> + var called = false; + mock.Setup(x => x.Execute()) + .Callback(() => called = true); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``1(System.Action{``0})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T">The argument type of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <example> + Invokes the given callback with the concrete invocation argument value. + <para> + Notice how the specific string argument is retrieved by simply declaring + it as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Callback((string command) => Console.WriteLine(command)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``2(System.Action{``0,``1})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``3(System.Action{``0,``1,``2})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``4(System.Action{``0,``1,``2,``3})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``5(System.Action{``0,``1,``2,``3,``4})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``6(System.Action{``0,``1,``2,``3,``4,``5})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``7(System.Action{``0,``1,``2,``3,``4,``5,``6})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``8(System.Action{``0,``1,``2,``3,``4,``5,``6,``7})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``9(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``10(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``11(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``12(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``13(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``14(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``15(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``16(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); + </code> + </example> + </member> + <member name="T:Moq.Language.ICallback`2"> + <summary> + Defines the <c>Callback</c> verb and overloads for callbacks on + setups that return a value. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TResult">Type of the return value of the setup.</typeparam> + </member> + <member name="M:Moq.Language.ICallback`2.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the method is called. + </summary> + <param name="action">The callback method to invoke.</param> + <example> + The following example specifies a callback to set a boolean value that can be used later: + <code> + var called = false; + mock.Setup(x => x.Execute()) + .Callback(() => called = true) + .Returns(true); + </code> + Note that in the case of value-returning methods, after the <c>Callback</c> + call you can still specify the return value. + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``1(System.Action{``0})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T">The type of the argument of the invoked method.</typeparam> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the concrete invocation argument value. + <para> + Notice how the specific string argument is retrieved by simply declaring + it as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Callback(command => Console.WriteLine(command)) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``2(System.Action{``0,``1})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``3(System.Action{``0,``1,``2})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``4(System.Action{``0,``1,``2,``3})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``5(System.Action{``0,``1,``2,``3,``4})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``6(System.Action{``0,``1,``2,``3,``4,``5})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``7(System.Action{``0,``1,``2,``3,``4,``5,``6})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``8(System.Action{``0,``1,``2,``3,``4,``5,``6,``7})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``9(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``10(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``11(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``12(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``13(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``14(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``15(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``16(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); + </code> + </example> + </member> + <member name="T:Moq.Language.IRaise`1"> + <summary> + Defines the <c>Raises</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"> + <summary> + Specifies the event that will be raised + when the setup is met. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="args">The event arguments to pass for the raised event.</param> + <example> + The following example shows how to raise an event when + the setup is met: + <code> + var mock = new Mock<IContainer>(); + + mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) + .Raises(add => add.Added += null, EventArgs.Empty); + </code> + </example> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Func{System.EventArgs})"> + <summary> + Specifies the event that will be raised + when the setup is matched. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="func">A function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Object[])"> + <summary> + Specifies the custom event that will be raised + when the setup is matched. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="args">The arguments to pass to the custom delegate (non EventHandler-compatible).</param> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``1(System.Action{`0},System.Func{``0,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``2(System.Action{`0},System.Func{``0,``1,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``3(System.Action{`0},System.Func{``0,``1,``2,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``4(System.Action{`0},System.Func{``0,``1,``2,``3,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``5(System.Action{`0},System.Func{``0,``1,``2,``3,``4,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``6(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``7(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``8(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``9(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``10(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``11(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``12(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``13(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``14(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``15(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <typeparam name="T15">The type of the fifteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``16(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <typeparam name="T15">The type of the fifteenth argument received by the expected invocation.</typeparam> + <typeparam name="T16">The type of the sixteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="T:Moq.Language.IReturns`2"> + <summary> + Defines the <c>Returns</c> verb. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TResult">Type of the return value from the expression.</typeparam> + </member> + <member name="M:Moq.Language.IReturns`2.Returns(`1)"> + <summary> + Specifies the value to return. + </summary> + <param name="value">The value to return, or <see langword="null"/>.</param> + <example> + Return a <c>true</c> value from the method call: + <code> + mock.Setup(x => x.Execute("ping")) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns(System.Func{`1})"> + <summary> + Specifies a function that will calculate the value to return from the method. + </summary> + <param name="valueFunction">The function that will calculate the return value.</param> + <example group="returns"> + Return a calculated value when the method is called: + <code> + mock.Setup(x => x.Execute("ping")) + .Returns(() => returnValues[0]); + </code> + The lambda expression to retrieve the return value is lazy-executed, + meaning that its value may change depending on the moment the method + is executed and the value the <c>returnValues</c> array has at + that moment. + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``1(System.Func{``0,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T">The type of the argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <example group="returns"> + Return a calculated value which is evaluated lazily at the time of the invocation. + <para> + The lookup list can change between invocations and the setup + will return different values accordingly. Also, notice how the specific + string argument is retrieved by simply declaring it as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Returns((string command) => returnValues[command]); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.CallBase"> + <summary> + Calls the real method of the object and returns its return value. + </summary> + <returns>The value calculated by the real method of the object.</returns> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``2(System.Func{``0,``1,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2) => arg1 + arg2); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``3(System.Func{``0,``1,``2,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``4(System.Func{``0,``1,``2,``3,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``5(System.Func{``0,``1,``2,``3,``4,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``6(System.Func{``0,``1,``2,``3,``4,``5,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``7(System.Func{``0,``1,``2,``3,``4,``5,``6,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``8(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``9(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``10(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``11(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``12(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``13(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``14(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``15(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``16(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); + </code> + </example> + </member> + <member name="T:Moq.Language.ISetupSequentialResult`1"> + <summary> + Language for ReturnSequence + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Returns(`0)"> + <summary> + Returns value + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Throws(System.Exception)"> + <summary> + Throws an exception + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Throws``1"> + <summary> + Throws an exception + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.CallBase"> + <summary> + Calls original method + </summary> + </member> + <member name="F:Moq.Linq.FluentMockVisitor.isFirst"> + <summary> + The first method call or member access will be the + last segment of the expression (depth-first traversal), + which is the one we have to Setup rather than FluentMock. + And the last one is the one we have to Mock.Get rather + than FluentMock. + </summary> + </member> + <member name="T:Moq.Mock"> + <summary> + Base class for mocks and static helper class with methods that + apply to mocked objects, such as <see cref="M:Moq.Mock.Get``1(``0)"/> to + retrieve a <see cref="T:Moq.Mock`1"/> from an object instance. + </summary> + </member> + <member name="M:Moq.Mock.Of``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mock.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="predicate">The predicate with the specification of how the mocked object should behave.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mock.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:Moq.Mock"/> class. + </summary> + </member> + <member name="M:Moq.Mock.Get``1(``0)"> + <summary> + Retrieves the mock object for the given object instance. + </summary><typeparam name="T"> + Type of the mock to retrieve. Can be omitted as it's inferred + from the object instance passed in as the <paramref name="mocked"/> instance. + </typeparam><param name="mocked">The instance of the mocked object.</param><returns>The mock associated with the mocked object.</returns><exception cref="T:System.ArgumentException"> + The received <paramref name="mocked"/> instance + was not created by Moq. + </exception><example group="advanced"> + The following example shows how to add a new setup to an object + instance which is not the original <see cref="T:Moq.Mock`1"/> but rather + the object associated with it: + <code> + // Typed instance, not the mock, is retrieved from some test API. + HttpContextBase context = GetMockContext(); + + // context.Request is the typed object from the "real" API + // so in order to add a setup to it, we need to get + // the mock that "owns" it + Mock<HttpRequestBase> request = Mock.Get(context.Request); + mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) + .Returns(tempUrl); + </code> + </example> + </member> + <member name="M:Moq.Mock.OnGetObject"> + <summary> + Returns the mocked object value. + </summary> + </member> + <member name="M:Moq.Mock.Verify"> + <summary> + Verifies that all verifiable expectations have been met. + </summary><example group="verification"> + This example sets up an expectation and marks it as verifiable. After + the mock is used, a <c>Verify()</c> call is issued on the mock + to ensure the method in the setup was invoked: + <code> + var mock = new Mock<IWarehouse>(); + this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); + ... + // other test code + ... + // Will throw if the test code has didn't call HasInventory. + this.Verify(); + </code> + </example><exception cref="T:Moq.MockException">Not all verifiable expectations were met.</exception> + </member> + <member name="M:Moq.Mock.VerifyAll"> + <summary> + Verifies all expectations regardless of whether they have + been flagged as verifiable. + </summary><example group="verification"> + This example sets up an expectation without marking it as verifiable. After + the mock is used, a <see cref="M:Moq.Mock.VerifyAll"/> call is issued on the mock + to ensure that all expectations are met: + <code> + var mock = new Mock<IWarehouse>(); + this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); + ... + // other test code + ... + // Will throw if the test code has didn't call HasInventory, even + // that expectation was not marked as verifiable. + this.VerifyAll(); + </code> + </example><exception cref="T:Moq.MockException">At least one expectation was not met.</exception> + </member> + <member name="M:Moq.Mock.GetInterceptor(System.Linq.Expressions.Expression,Moq.Mock)"> + <summary> + Gets the interceptor target for the given expression and root mock, + building the intermediate hierarchy of mock objects if necessary. + </summary> + </member> + <member name="M:Moq.Mock.DoRaise(System.Reflection.EventInfo,System.EventArgs)"> + <summary> + Raises the associated event with the given + event argument data. + </summary> + </member> + <member name="M:Moq.Mock.DoRaise(System.Reflection.EventInfo,System.Object[])"> + <summary> + Raises the associated event with the given + event argument data. + </summary> + </member> + <member name="M:Moq.Mock.As``1"> + <summary> + Adds an interface implementation to the mock, + allowing setups to be specified for it. + </summary><remarks> + This method can only be called before the first use + of the mock <see cref="P:Moq.Mock.Object"/> property, at which + point the runtime type has already been generated + and no more interfaces can be added to it. + <para> + Also, <typeparamref name="TInterface"/> must be an + interface and not a class, which must be specified + when creating the mock instead. + </para> + </remarks><exception cref="T:System.InvalidOperationException"> + The mock type + has already been generated by accessing the <see cref="P:Moq.Mock.Object"/> property. + </exception><exception cref="T:System.ArgumentException"> + The <typeparamref name="TInterface"/> specified + is not an interface. + </exception><example> + The following example creates a mock for the main interface + and later adds <see cref="T:System.IDisposable"/> to it to verify + it's called by the consumer code: + <code> + var mock = new Mock<IProcessor>(); + mock.Setup(x => x.Execute("ping")); + + // add IDisposable interface + var disposable = mock.As<IDisposable>(); + disposable.Setup(d => d.Dispose()).Verifiable(); + </code> + </example><typeparam name="TInterface">Type of interface to cast the mock to.</typeparam> + </member> + <member name="M:Moq.Mock.SetReturnsDefault``1(``0)"> + <!-- No matching elements were found for the following include tag --><include file="Mock.Generic.xdoc" path="docs/doc[@for="Mock.SetReturnDefault{TReturn}"]/*"/> + </member> + <member name="P:Moq.Mock.Behavior"> + <summary> + Behavior of the mock, according to the value set in the constructor. + </summary> + </member> + <member name="P:Moq.Mock.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.Mock.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="P:Moq.Mock.Object"> + <summary> + Gets the mocked object instance. + </summary> + </member> + <member name="P:Moq.Mock.MockedType"> + <summary> + Retrieves the type of the mocked object, its generic type argument. + This is used in the auto-mocking of hierarchy access. + </summary> + </member> + <member name="P:Moq.Mock.DelegateInterfaceMethod"> + <summary> + If this is a mock of a delegate, this property contains the method + on the autogenerated interface so that we can convert setup + verify + expressions on the delegate into expressions on the interface proxy. + </summary> + </member> + <member name="P:Moq.Mock.IsDelegateMock"> + <summary> + Allows to check whether expression conversion to the <see cref="P:Moq.Mock.DelegateInterfaceMethod"/> + must be performed on the mock, without causing unnecessarily early initialization of + the mock instance, which breaks As{T}. + </summary> + </member> + <member name="P:Moq.Mock.DefaultValueProvider"> + <summary> + Specifies the class that will determine the default + value to return when invocations are made that + have no setups and need to return a default + value (for loose mocks). + </summary> + </member> + <member name="P:Moq.Mock.ImplementedInterfaces"> + <summary> + Exposes the list of extra interfaces implemented by the mock. + </summary> + </member> + <member name="T:Moq.MockRepository"> + <summary> + Utility repository class to use to construct multiple + mocks when consistent verification is + desired for all of them. + </summary> + <remarks> + If multiple mocks will be created during a test, passing + the desired <see cref="T:Moq.MockBehavior"/> (if different than the + <see cref="F:Moq.MockBehavior.Default"/> or the one + passed to the repository constructor) and later verifying each + mock can become repetitive and tedious. + <para> + This repository class helps in that scenario by providing a + simplified creation of multiple mocks with a default + <see cref="T:Moq.MockBehavior"/> (unless overriden by calling + <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/>) and posterior verification. + </para> + </remarks> + <example group="repository"> + The following is a straightforward example on how to + create and automatically verify strict mocks using a <see cref="T:Moq.MockRepository"/>: + <code> + var repository = new MockRepository(MockBehavior.Strict); + + var foo = repository.Create<IFoo>(); + var bar = repository.Create<IBar>(); + + // no need to call Verifiable() on the setup + // as we'll be validating all of them anyway. + foo.Setup(f => f.Do()); + bar.Setup(b => b.Redo()); + + // exercise the mocks here + + repository.VerifyAll(); + // At this point all setups are already checked + // and an optional MockException might be thrown. + // Note also that because the mocks are strict, any invocation + // that doesn't have a matching setup will also throw a MockException. + </code> + The following examples shows how to setup the repository + to create loose mocks and later verify only verifiable setups: + <code> + var repository = new MockRepository(MockBehavior.Loose); + + var foo = repository.Create<IFoo>(); + var bar = repository.Create<IBar>(); + + // this setup will be verified when we verify the repository + foo.Setup(f => f.Do()).Verifiable(); + + // this setup will NOT be verified + foo.Setup(f => f.Calculate()); + + // this setup will be verified when we verify the repository + bar.Setup(b => b.Redo()).Verifiable(); + + // exercise the mocks here + // note that because the mocks are Loose, members + // called in the interfaces for which no matching + // setups exist will NOT throw exceptions, + // and will rather return default values. + + repository.Verify(); + // At this point verifiable setups are already checked + // and an optional MockException might be thrown. + </code> + The following examples shows how to setup the repository with a + default strict behavior, overriding that default for a + specific mock: + <code> + var repository = new MockRepository(MockBehavior.Strict); + + // this particular one we want loose + var foo = repository.Create<IFoo>(MockBehavior.Loose); + var bar = repository.Create<IBar>(); + + // specify setups + + // exercise the mocks here + + repository.Verify(); + </code> + </example> + <seealso cref="T:Moq.MockBehavior"/> + </member> + <member name="T:Moq.MockFactory"> + <summary> + Utility factory class to use to construct multiple + mocks when consistent verification is + desired for all of them. + </summary> + <remarks> + If multiple mocks will be created during a test, passing + the desired <see cref="T:Moq.MockBehavior"/> (if different than the + <see cref="F:Moq.MockBehavior.Default"/> or the one + passed to the factory constructor) and later verifying each + mock can become repetitive and tedious. + <para> + This factory class helps in that scenario by providing a + simplified creation of multiple mocks with a default + <see cref="T:Moq.MockBehavior"/> (unless overriden by calling + <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/>) and posterior verification. + </para> + </remarks> + <example group="factory"> + The following is a straightforward example on how to + create and automatically verify strict mocks using a <see cref="T:Moq.MockFactory"/>: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(); + var bar = factory.Create<IBar>(); + + // no need to call Verifiable() on the setup + // as we'll be validating all of them anyway. + foo.Setup(f => f.Do()); + bar.Setup(b => b.Redo()); + + // exercise the mocks here + + factory.VerifyAll(); + // At this point all setups are already checked + // and an optional MockException might be thrown. + // Note also that because the mocks are strict, any invocation + // that doesn't have a matching setup will also throw a MockException. + </code> + The following examples shows how to setup the factory + to create loose mocks and later verify only verifiable setups: + <code> + var factory = new MockFactory(MockBehavior.Loose); + + var foo = factory.Create<IFoo>(); + var bar = factory.Create<IBar>(); + + // this setup will be verified when we verify the factory + foo.Setup(f => f.Do()).Verifiable(); + + // this setup will NOT be verified + foo.Setup(f => f.Calculate()); + + // this setup will be verified when we verify the factory + bar.Setup(b => b.Redo()).Verifiable(); + + // exercise the mocks here + // note that because the mocks are Loose, members + // called in the interfaces for which no matching + // setups exist will NOT throw exceptions, + // and will rather return default values. + + factory.Verify(); + // At this point verifiable setups are already checked + // and an optional MockException might be thrown. + </code> + The following examples shows how to setup the factory with a + default strict behavior, overriding that default for a + specific mock: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + // this particular one we want loose + var foo = factory.Create<IFoo>(MockBehavior.Loose); + var bar = factory.Create<IBar>(); + + // specify setups + + // exercise the mocks here + + factory.Verify(); + </code> + </example> + <seealso cref="T:Moq.MockBehavior"/> + </member> + <member name="M:Moq.MockFactory.#ctor(Moq.MockBehavior)"> + <summary> + Initializes the factory with the given <paramref name="defaultBehavior"/> + for newly created mocks from the factory. + </summary> + <param name="defaultBehavior">The behavior to use for mocks created + using the <see cref="M:Moq.MockFactory.Create``1"/> factory method if not overriden + by using the <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/> overload.</param> + </member> + <member name="M:Moq.MockFactory.Create``1"> + <summary> + Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> + specified at factory construction time. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example ignore="true"> + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(); + // use mock on tests + + factory.VerifyAll(); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(System.Object[])"> + <summary> + Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> + specified at factory construction time and with the + the given constructor arguments for the class. + </summary> + <remarks> + The mock will try to find the best match constructor given the + constructor arguments, and invoke that to initialize the instance. + This applies only to classes, not interfaces. + </remarks> + <typeparam name="T">Type to mock.</typeparam> + <param name="args">Constructor arguments for mocked classes.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example ignore="true"> + <code> + var factory = new MockFactory(MockBehavior.Default); + + var mock = factory.Create<MyBase>("Foo", 25, true); + // use mock on tests + + factory.Verify(); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"> + <summary> + Creates a new mock with the given <paramref name="behavior"/>. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">Behavior to use for the mock, which overrides + the default behavior specified at factory construction time.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example group="factory"> + The following example shows how to create a mock with a different + behavior to that specified as the default for the factory: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(MockBehavior.Loose); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior,System.Object[])"> + <summary> + Creates a new mock with the given <paramref name="behavior"/> + and with the the given constructor arguments for the class. + </summary> + <remarks> + The mock will try to find the best match constructor given the + constructor arguments, and invoke that to initialize the instance. + This applies only to classes, not interfaces. + </remarks> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">Behavior to use for the mock, which overrides + the default behavior specified at factory construction time.</param> + <param name="args">Constructor arguments for mocked classes.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example group="factory"> + The following example shows how to create a mock with a different + behavior to that specified as the default for the factory, passing + constructor arguments: + <code> + var factory = new MockFactory(MockBehavior.Default); + + var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.CreateMock``1(Moq.MockBehavior,System.Object[])"> + <summary> + Implements creation of a new mock within the factory. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">The behavior for the new mock.</param> + <param name="args">Optional arguments for the construction of the mock.</param> + </member> + <member name="M:Moq.MockFactory.Verify"> + <summary> + Verifies all verifiable expectations on all mocks created + by this factory. + </summary> + <seealso cref="M:Moq.Mock.Verify"/> + <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception> + </member> + <member name="M:Moq.MockFactory.VerifyAll"> + <summary> + Verifies all verifiable expectations on all mocks created + by this factory. + </summary> + <seealso cref="M:Moq.Mock.Verify"/> + <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception> + </member> + <member name="M:Moq.MockFactory.VerifyMocks(System.Action{Moq.Mock})"> + <summary> + Invokes <paramref name="verifyAction"/> for each mock + in <see cref="P:Moq.MockFactory.Mocks"/>, and accumulates the resulting + <see cref="T:Moq.MockVerificationException"/> that might be + thrown from the action. + </summary> + <param name="verifyAction">The action to execute against + each mock.</param> + </member> + <member name="P:Moq.MockFactory.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.MockFactory.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="P:Moq.MockFactory.Mocks"> + <summary> + Gets the mocks that have been created by this factory and + that will get verified together. + </summary> + </member> + <member name="M:Moq.MockRepository.Of``1"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.MockRepository.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.MockRepository.OneOf``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.MockRepository.OneOf``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.MockRepository.CreateMockQuery``1"> + <summary> + Creates the mock query with the underlying queriable implementation. + </summary> + </member> + <member name="M:Moq.MockRepository.CreateQueryable``1"> + <summary> + Wraps the enumerator inside a queryable. + </summary> + </member> + <member name="M:Moq.MockRepository.CreateMocks``1"> + <summary> + Method that is turned into the actual call from .Query{T}, to + transform the queryable query into a normal enumerable query. + This method is never used directly by consumers. + </summary> + </member> + <member name="M:Moq.MockRepository.#ctor(Moq.MockBehavior)"> + <summary> + Initializes the repository with the given <paramref name="defaultBehavior"/> + for newly created mocks from the repository. + </summary> + <param name="defaultBehavior">The behavior to use for mocks created + using the <see cref="M:Moq.MockFactory.Create``1"/> repository method if not overriden + by using the <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/> overload.</param> + </member> + <member name="T:Moq.EmptyDefaultValueProvider"> + <summary> + A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value + for invocations that do not have setups or return values, with loose mocks. + This is the default behavior for a mock. + </summary> + </member> + <member name="T:Moq.IDefaultValueProvider"> + <summary> + Interface to be implemented by classes that determine the + default value of non-expected invocations. + </summary> + </member> + <member name="M:Moq.IDefaultValueProvider.DefineDefault``1(``0)"> + <summary> + Defines the default value to return in all the methods returning <typeparamref name="T"/>. + </summary><typeparam name="T">The type of the return value.</typeparam><param name="value">The value to set as default.</param> + </member> + <member name="M:Moq.IDefaultValueProvider.ProvideDefault(System.Reflection.MethodInfo)"> + <summary> + Provides a value for the given member and arguments. + </summary><param name="member"> + The member to provide a default value for. + </param> + </member> + <member name="T:Moq.ExpressionStringBuilder"> + <summary> + The intention of <see cref="T:Moq.ExpressionStringBuilder"/> is to create a more readable + string representation for the failure message. + </summary> + </member> + <member name="T:Moq.Language.Flow.ICallbackResult"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IThrows"> + <summary> + Defines the <c>Throws</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IThrows.Throws(System.Exception)"> + <summary> + Specifies the exception to throw when the method is invoked. + </summary> + <param name="exception">Exception instance to throw.</param> + <example> + This example shows how to throw an exception when the method is + invoked with an empty string argument: + <code> + mock.Setup(x => x.Execute("")) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.Language.IThrows.Throws``1"> + <summary> + Specifies the type of exception to throw when the method is invoked. + </summary> + <typeparam name="TException">Type of exception to instantiate and throw when the setup is matched.</typeparam> + <example> + This example shows how to throw an exception when the method is + invoked with an empty string argument: + <code> + mock.Setup(x => x.Execute("")) + .Throws<ArgumentException>(); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IThrowsResult"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IOccurrence"> + <summary> + Defines occurrence members to constraint setups. + </summary> + </member> + <member name="M:Moq.Language.IOccurrence.AtMostOnce"> + <summary> + The expected invocation can happen at most once. + </summary> + <example> + <code> + var mock = new Mock<ICommand>(); + mock.Setup(foo => foo.Execute("ping")) + .AtMostOnce(); + </code> + </example> + </member> + <member name="M:Moq.Language.IOccurrence.AtMost(System.Int32)"> + <summary> + The expected invocation can happen at most specified number of times. + </summary> + <param name="callCount">The number of times to accept calls.</param> + <example> + <code> + var mock = new Mock<ICommand>(); + mock.Setup(foo => foo.Execute("ping")) + .AtMost( 5 ); + </code> + </example> + </member> + <member name="T:Moq.Language.IVerifies"> + <summary> + Defines the <c>Verifiable</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IVerifies.Verifiable"> + <summary> + Marks the expectation as verifiable, meaning that a call + to <see cref="M:Moq.Mock.Verify"/> will check if this particular + expectation was met. + </summary> + <example> + The following example marks the expectation as verifiable: + <code> + mock.Expect(x => x.Execute("ping")) + .Returns(true) + .Verifiable(); + </code> + </example> + </member> + <member name="M:Moq.Language.IVerifies.Verifiable(System.String)"> + <summary> + Marks the expectation as verifiable, meaning that a call + to <see cref="M:Moq.Mock.Verify"/> will check if this particular + expectation was met, and specifies a message for failures. + </summary> + <example> + The following example marks the expectation as verifiable: + <code> + mock.Expect(x => x.Execute("ping")) + .Returns(true) + .Verifiable("Ping should be executed always!"); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.ISetup`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.MethodCallReturn"> + <devdoc> + We need this non-generics base class so that + we can use <see cref="P:Moq.MethodCallReturn.HasReturnValue"/> from + generic code. + </devdoc> + </member> + <member name="T:Moq.Language.Flow.ISetup`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.Flow.IReturnsThrows`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.Flow.ISetupGetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallbackGetter`2"> + <summary> + Defines the <c>Callback</c> verb for property getter setups. + </summary> + <seealso cref="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"/> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.ICallbackGetter`2.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the property is retrieved. + </summary> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the property value being set. + <code> + mock.SetupGet(x => x.Suspended) + .Callback(() => called = true) + .Returns(true); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IReturnsThrowsGetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IReturnsGetter`2"> + <summary> + Defines the <c>Returns</c> verb for property get setups. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.Returns(`1)"> + <summary> + Specifies the value to return. + </summary> + <param name="value">The value to return, or <see langword="null"/>.</param> + <example> + Return a <c>true</c> value from the property getter call: + <code> + mock.SetupGet(x => x.Suspended) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.Returns(System.Func{`1})"> + <summary> + Specifies a function that will calculate the value to return for the property. + </summary> + <param name="valueFunction">The function that will calculate the return value.</param> + <example> + Return a calculated value when the property is retrieved: + <code> + mock.SetupGet(x => x.Suspended) + .Returns(() => returnValues[0]); + </code> + The lambda expression to retrieve the return value is lazy-executed, + meaning that its value may change depending on the moment the property + is retrieved and the value the <c>returnValues</c> array has at + that moment. + </example> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.CallBase"> + <summary> + Calls the real property of the object and returns its return value. + </summary> + <returns>The value calculated by the real property of the object.</returns> + </member> + <member name="T:Moq.Language.Flow.IReturnsResult`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:System.Action`5"> + <summary> + Encapsulates a method that has five parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`6"> + <summary> + Encapsulates a method that has five parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`6"> + <summary> + Encapsulates a method that has six parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`7"> + <summary> + Encapsulates a method that has six parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`7"> + <summary> + Encapsulates a method that has seven parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`8"> + <summary> + Encapsulates a method that has seven parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`8"> + <summary> + Encapsulates a method that has eight parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`9"> + <summary> + Encapsulates a method that has eight parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`9"> + <summary> + Encapsulates a method that has nine parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`10"> + <summary> + Encapsulates a method that has nine parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`10"> + <summary> + Encapsulates a method that has ten parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`11"> + <summary> + Encapsulates a method that has ten parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`11"> + <summary> + Encapsulates a method that has eleven parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`12"> + <summary> + Encapsulates a method that has eleven parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`12"> + <summary> + Encapsulates a method that has twelve parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`13"> + <summary> + Encapsulates a method that has twelve parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`13"> + <summary> + Encapsulates a method that has thirteen parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`14"> + <summary> + Encapsulates a method that has thirteen parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`14"> + <summary> + Encapsulates a method that has fourteen parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`15"> + <summary> + Encapsulates a method that has fourteen parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`15"> + <summary> + Encapsulates a method that has fifteen parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T15">The type of the fifteenth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg15">The fifteenth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`16"> + <summary> + Encapsulates a method that has fifteen parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T15">The type of the fifteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg15">The fifteenth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:System.Action`16"> + <summary> + Encapsulates a method that has sixteen parameters and does not return a value. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T15">The type of the fifteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T16">The type of the sixteenth parameter of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg15">The fifteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg16">The sixteenth parameter of the method that this delegate encapsulates.</param> + </member> + <member name="T:System.Func`17"> + <summary> + Encapsulates a method that has sixteen parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter. + </summary> + <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T9">The type of the nineth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T10">The type of the tenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T11">The type of the eleventh parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T12">The type of the twelfth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T13">The type of the thirteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T14">The type of the fourteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T15">The type of the fifteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="T16">The type of the sixteenth parameter of the method that this delegate encapsulates.</typeparam> + <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam> + <param name="arg1">The first parameter of the method that this delegate encapsulates.</param> + <param name="arg2">The second parameter of the method that this delegate encapsulates.</param> + <param name="arg3">The third parameter of the method that this delegate encapsulates.</param> + <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param> + <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param> + <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param> + <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param> + <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param> + <param name="arg9">The nineth parameter of the method that this delegate encapsulates.</param> + <param name="arg10">The tenth parameter of the method that this delegate encapsulates.</param> + <param name="arg11">The eleventh parameter of the method that this delegate encapsulates.</param> + <param name="arg12">The twelfth parameter of the method that this delegate encapsulates.</param> + <param name="arg13">The thirteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg14">The fourteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg15">The fifteenth parameter of the method that this delegate encapsulates.</param> + <param name="arg16">The sixteenth parameter of the method that this delegate encapsulates.</param> + <return>The return value of the method that this delegate encapsulates.</return> + </member> + <member name="T:Moq.MockExtensions"> + <summary> + Provides additional methods on mocks. + </summary> + <remarks> + Those methods are useful for Testeroids support. + </remarks> + </member> + <member name="M:Moq.MockExtensions.ResetCalls(Moq.Mock)"> + <summary> + Resets the calls previously made on the specified mock. + </summary> + <param name="mock">The mock whose calls need to be reset.</param> + </member> + <member name="T:Moq.MockSequence"> + <summary> + Helper class to setup a full trace between many mocks + </summary> + </member> + <member name="M:Moq.MockSequence.#ctor"> + <summary> + Initialize a trace setup + </summary> + </member> + <member name="P:Moq.MockSequence.Cyclic"> + <summary> + Allow sequence to be repeated + </summary> + </member> + <member name="T:Moq.MockSequenceHelper"> + <summary> + define nice api + </summary> + </member> + <member name="M:Moq.MockSequenceHelper.InSequence``1(Moq.Mock{``0},Moq.MockSequence)"> + <summary> + Perform an expectation in the trace. + </summary> + </member> + <member name="T:Moq.MatcherAttribute"> + <summary> + Marks a method as a matcher, which allows complete replacement + of the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary> + <remarks> + <b>This feature has been deprecated in favor of the new + and simpler <see cref="T:Moq.Match`1"/>. + </b> + <para> + The argument matching is used to determine whether a concrete + invocation in the mock matches a given setup. This + matching mechanism is fully extensible. + </para> + <para> + There are two parts of a matcher: the compiler matcher + and the runtime matcher. + <list type="bullet"> + <item> + <term>Compiler matcher</term> + <description>Used to satisfy the compiler requirements for the + argument. Needs to be a method optionally receiving any arguments + you might need for the matching, but with a return type that + matches that of the argument. + <para> + Let's say I want to match a lists of orders that contains + a particular one. I might create a compiler matcher like the following: + </para> + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return null; + } + } + </code> + Now we can invoke this static method instead of an argument in an + invocation: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + </code> + Note that the return value from the compiler matcher is irrelevant. + This method will never be called, and is just used to satisfy the + compiler and to signal Moq that this is not a method that we want + to be invoked at runtime. + </description> + </item> + <item> + <term>Runtime matcher</term> + <description> + The runtime matcher is the one that will actually perform evaluation + when the test is run, and is defined by convention to have the + same signature as the compiler matcher, but where the return + value is the first argument to the call, which contains the + object received by the actual invocation at runtime: + <code> + public static bool Contains(IEnumerable<Order> orders, Order order) + { + return orders.Contains(order); + } + </code> + At runtime, the mocked method will be invoked with a specific + list of orders. This value will be passed to this runtime + matcher as the first argument, while the second argument is the + one specified in the setup (<c>x.Save(Orders.Contains(order))</c>). + <para> + The boolean returned determines whether the given argument has been + matched. If all arguments to the expected method are matched, then + the setup matches and is evaluated. + </para> + </description> + </item> + </list> + </para> + Using this extensible infrastructure, you can easily replace the entire + <see cref="T:Moq.It"/> set of matchers with your own. You can also avoid the + typical (and annoying) lengthy expressions that result when you have + multiple arguments that use generics. + </remarks> + <example> + The following is the complete example explained above: + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return null; + } + + public static bool Contains(IEnumerable<Order> orders, Order order) + { + return orders.Contains(order); + } + } + </code> + And the concrete test using this matcher: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + + // use mock, invoke Save, and have the matcher filter. + </code> + </example> + </member> + <member name="T:Moq.Mock`1"> + <summary> + Provides a mock implementation of <typeparamref name="T"/>. + </summary><remarks> + Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. + <para> + The behavior of the mock with regards to the setups and the actual calls is determined + by the optional <see cref="T:Moq.MockBehavior"/> that can be passed to the <see cref="M:Moq.Mock`1.#ctor(Moq.MockBehavior)"/> + constructor. + </para> + </remarks><typeparam name="T">Type to mock, which can be an interface or a class.</typeparam><example group="overview" order="0"> + The following example shows establishing setups with specific values + for method invocations: + <code> + // Arrange + var order = new Order(TALISKER, 50); + var mock = new Mock<IWarehouse>(); + + mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); + + // Act + order.Fill(mock.Object); + + // Assert + Assert.True(order.IsFilled); + </code> + The following example shows how to use the <see cref="T:Moq.It"/> class + to specify conditions for arguments instead of specific values: + <code> + // Arrange + var order = new Order(TALISKER, 50); + var mock = new Mock<IWarehouse>(); + + // shows how to expect a value within a range + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsInRange(0, 100, Range.Inclusive))) + .Returns(false); + + // shows how to throw for unexpected calls. + mock.Setup(x => x.Remove( + It.IsAny<string>(), + It.IsAny<int>())) + .Throws(new InvalidOperationException()); + + // Act + order.Fill(mock.Object); + + // Assert + Assert.False(order.IsFilled); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Expect(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.Expect``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.#ctor(System.Boolean)"> + <summary> + Ctor invoked by AsTInterface exclusively. + </summary> + </member> + <member name="M:Moq.Mock`1.#ctor"> + <summary> + Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see>. + </summary><example> + <code>var mock = new Mock<IFormatProvider>();</code> + </example> + </member> + <member name="M:Moq.Mock`1.#ctor(System.Object[])"> + <summary> + Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see> and with + the given constructor arguments for the class. (Only valid when <typeparamref name="T"/> is a class) + </summary><remarks> + The mock will try to find the best match constructor given the constructor arguments, and invoke that + to initialize the instance. This applies only for classes, not interfaces. + </remarks><example> + <code>var mock = new Mock<MyProvider>(someArgument, 25);</code> + </example><param name="args">Optional constructor arguments if the mocked type is a class.</param> + </member> + <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior)"> + <summary> + Initializes an instance of the mock with the specified <see cref="T:Moq.MockBehavior">behavior</see>. + </summary><example> + <code>var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed);</code> + </example><param name="behavior">Behavior of the mock.</param> + </member> + <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior,System.Object[])"> + <summary> + Initializes an instance of the mock with a specific <see cref="T:Moq.MockBehavior">behavior</see> with + the given constructor arguments for the class. + </summary><remarks> + The mock will try to find the best match constructor given the constructor arguments, and invoke that + to initialize the instance. This applies only to classes, not interfaces. + </remarks><example> + <code>var mock = new Mock<MyProvider>(someArgument, 25);</code> + </example><param name="behavior">Behavior of the mock.</param><param name="args">Optional constructor arguments if the mocked type is a class.</param> + </member> + <member name="M:Moq.Mock`1.OnGetObject"> + <summary> + Returns the mocked object value. + </summary> + </member> + <member name="M:Moq.Mock`1.Setup(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a void method. + </summary><remarks> + If more than one setup is specified for the same method or property, + the latest one wins and is the one that will be executed. + </remarks><param name="expression">Lambda expression that specifies the expected method invocation.</param><example group="setups"> + <code> + var mock = new Mock<IProcessor>(); + mock.Setup(x => x.Execute("ping")); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Setup``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a value returning method. + </summary><typeparam name="TResult">Type of the return value. Typically omitted as it can be inferred from the expression.</typeparam><remarks> + If more than one setup is specified for the same method or property, + the latest one wins and is the one that will be executed. + </remarks><param name="expression">Lambda expression that specifies the method invocation.</param><example group="setups"> + <code> + mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property getter. + </summary><remarks> + If more than one setup is set for the same property getter, + the latest one wins and is the one that will be executed. + </remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="expression">Lambda expression that specifies the property getter.</param><example group="setups"> + <code> + mock.SetupGet(x => x.Suspended) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupSet``1(System.Action{`0})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter. + </summary><remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + <para> + This overloads allows the use of a callback already + typed for the property type. + </para> + </remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="setterExpression">The Lambda expression that sets a property to a value.</param><example group="setups"> + <code> + mock.SetupSet(x => x.Suspended = true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupSet(System.Action{`0})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter. + </summary><remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + </remarks><param name="setterExpression">Lambda expression that sets a property to a value.</param><example group="setups"> + <code> + mock.SetupSet(x => x.Suspended = true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies that the given property should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. (this is also + known as "stubbing"). + </summary><typeparam name="TProperty"> + Type of the property, inferred from the property + expression (does not need to be specified). + </typeparam><param name="property">Property expression to stub.</param><example> + If you have an interface with an int property <c>Value</c>, you might + stub it using the following straightforward call: + <code> + var mock = new Mock<IHaveValue>(); + mock.Stub(v => v.Value); + </code> + After the <c>Stub</c> call has been issued, setting and + retrieving the object value will behave as expected: + <code> + IHaveValue v = mock.Object; + + v.Value = 5; + Assert.Equal(5, v.Value); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)"> + <summary> + Specifies that the given property should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. This overload + allows setting the initial value for the property. (this is also + known as "stubbing"). + </summary><typeparam name="TProperty"> + Type of the property, inferred from the property + expression (does not need to be specified). + </typeparam><param name="property">Property expression to stub.</param><param name="initialValue">Initial value for the property.</param><example> + If you have an interface with an int property <c>Value</c>, you might + stub it using the following straightforward call: + <code> + var mock = new Mock<IHaveValue>(); + mock.SetupProperty(v => v.Value, 5); + </code> + After the <c>SetupProperty</c> call has been issued, setting and + retrieving the object value will behave as expected: + <code> + IHaveValue v = mock.Object; + // Initial value was stored + Assert.Equal(5, v.Value); + + // New value set which changes the initial value + v.Value = 6; + Assert.Equal(6, v.Value); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupAllProperties"> + <summary> + Specifies that the all properties on the mock should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. (this is also + known as "stubbing"). The default value for each property will be the + one generated as specified by the <see cref="P:Moq.Mock.DefaultValue"/> property for the mock. + </summary><remarks> + If the mock <see cref="P:Moq.Mock.DefaultValue"/> is set to <see cref="F:Moq.DefaultValue.Mock"/>, + the mocked default values will also get all properties setup recursively. + </remarks> + </member> + <member name="M:Moq.Mock`1.When(System.Func{System.Boolean})"> + <!-- No matching elements were found for the following include tag --><include file="Mock.Generic.xdoc" path="docs/doc[@for="Mock{T}.When"]/*"/> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IProcessor>(); + // exercise mock + //... + // Will throw if the test code didn't call Execute with a "ping" string argument. + mock.Verify(proc => proc.Execute("ping")); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.Func{Moq.Times})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IProcessor>(); + // exercise mock + //... + // Will throw if the test code didn't call Execute with a "ping" string argument. + mock.Verify(proc => proc.Execute("ping")); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times,System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't call HasInventory. + mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock. Use in conjuntion + with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times})"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock. Use in conjuntion + with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock, specifying a failure + error message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't call HasInventory. + mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Verifies that a property was read on the mock. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was retrieved from it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't retrieve the IsClosed property. + mock.VerifyGet(warehouse => warehouse.IsClosed); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)"> + <summary> + Verifies that a property was read on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times})"> + <summary> + Verifies that a property was read on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was retrieved from it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't retrieve the IsClosed property. + mock.VerifyGet(warehouse => warehouse.IsClosed); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0})"> + <summary> + Verifies that a property was set on the mock. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was set on it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed = true); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times)"> + <summary> + Verifies that a property was set on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.Func{Moq.Times})"> + <summary> + Verifies that a property was set on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was set on it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times,System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.EventArgs)"> + <summary> + Raises the event referenced in <paramref name="eventExpression"/> using + the given <paramref name="args"/> argument. + </summary><exception cref="T:System.ArgumentException"> + The <paramref name="args"/> argument is + invalid for the target event invocation, or the <paramref name="eventExpression"/> is + not an event attach or detach expression. + </exception><example> + The following example shows how to raise a <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event: + <code> + var mock = new Mock<IViewModel>(); + + mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); + </code> + </example><example> + This example shows how to invoke an event with a custom event arguments + class in a view that will cause its corresponding presenter to + react by changing its state: + <code> + var mockView = new Mock<IOrdersView>(); + var presenter = new OrdersPresenter(mockView.Object); + + // Check that the presenter has no selection by default + Assert.Null(presenter.SelectedOrder); + + // Raise the event with a specific arguments data + mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); + + // Now the presenter reacted to the event, and we have a selected order + Assert.NotNull(presenter.SelectedOrder); + Assert.Equal("moq", presenter.SelectedOrder.ProductName); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.Object[])"> + <summary> + Raises the event referenced in <paramref name="eventExpression"/> using + the given <paramref name="args"/> argument for a non-EventHandler typed event. + </summary><exception cref="T:System.ArgumentException"> + The <paramref name="args"/> arguments are + invalid for the target event invocation, or the <paramref name="eventExpression"/> is + not an event attach or detach expression. + </exception><example> + The following example shows how to raise a custom event that does not adhere to + the standard <c>EventHandler</c>: + <code> + var mock = new Mock<IViewModel>(); + + mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); + </code> + </example> + </member> + <member name="P:Moq.Mock`1.Object"> + <summary> + Exposes the mocked object instance. + </summary> + </member> + <member name="P:Moq.Mock`1.DelegateInterfaceMethod"> + <inheritdoc /> + </member> + <member name="T:Moq.MockLegacyExtensions"> + <summary> + Provides legacy API members as extensions so that + existing code continues to compile, but new code + doesn't see then. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1,System.String)"> + <summary> + Obsolete. + </summary> + </member> + <member name="T:Moq.ObsoleteMockExtensions"> + <summary> + Provides additional methods on mocks. + </summary> + <devdoc> + Provided as extension methods as they confuse the compiler + with the overloads taking Action. + </devdoc> + </member> + <member name="M:Moq.ObsoleteMockExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter, regardless of its value. + </summary> + <remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + </remarks> + <typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam> + <typeparam name="T">Type of the mock.</typeparam> + <param name="mock">The target mock for the setup.</param> + <param name="expression">Lambda expression that specifies the property setter.</param> + <example group="setups"> + <code> + mock.SetupSet(x => x.Suspended); + </code> + </example> + <devdoc> + This method is not legacy, but must be on an extension method to avoid + confusing the compiler with the new Action syntax. + </devdoc> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Verifies that a property has been set on the mock, regarless of its value. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <param name="expression">Expression to verify.</param> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)"> + <summary> + Verifies that a property has been set on the mock, specifying a failure + error message. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <param name="expression">Expression to verify.</param> + <param name="failMessage">Message to show if verification fails.</param> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times)"> + <summary> + Verifies that a property has been set on the mock, regardless + of the value but only the specified number of times. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="expression">Expression to verify.</param> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times,System.String)"> + <summary> + Verifies that a property has been set on the mock, regardless + of the value but only the specified number of times, and specifying a failure + error message. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="failMessage">Message to show if verification fails.</param> + <param name="expression">Expression to verify.</param> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="T:Moq.SequenceExtensions"> + <summary> + Helper for sequencing return values in the same method. + </summary> + </member> + <member name="M:Moq.SequenceExtensions.SetupSequence``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Return a sequence of values, once per call. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToLambda(System.Linq.Expressions.Expression)"> + <summary> + Casts the expression to a lambda expression, removing + a cast if there's any. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToMethodCall(System.Linq.Expressions.LambdaExpression)"> + <summary> + Casts the body of the lambda expression to a <see cref="T:System.Linq.Expressions.MethodCallExpression"/>. + </summary> + <exception cref="T:System.ArgumentException">If the body is not a method call.</exception> + </member> + <member name="M:Moq.ExpressionExtensions.ToPropertyInfo(System.Linq.Expressions.LambdaExpression)"> + <summary> + Converts the body of the lambda expression into the <see cref="T:System.Reflection.PropertyInfo"/> referenced by it. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.LambdaExpression)"> + <summary> + Checks whether the body of the lambda expression is a property access. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.Expression)"> + <summary> + Checks whether the expression is a property access. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.LambdaExpression)"> + <summary> + Checks whether the body of the lambda expression is a property indexer, which is true + when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose + <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> + equal to <see langword="true"/>. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.Expression)"> + <summary> + Checks whether the expression is a property indexer, which is true + when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose + <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> + equal to <see langword="true"/>. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.CastTo``1(System.Linq.Expressions.Expression)"> + <summary> + Creates an expression that casts the given expression to the <typeparamref name="T"/> + type. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToStringFixed(System.Linq.Expressions.Expression)"> + <devdoc> + TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 + is fixed. + </devdoc> + </member> + <member name="M:Moq.ExpressionExtensions.GetCallInfo(System.Linq.Expressions.LambdaExpression,Moq.Mock)"> + <summary> + Extracts, into a common form, information from a <see cref="T:System.Linq.Expressions.LambdaExpression"/> + around either a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> (for a normal method call) + or a <see cref="T:System.Linq.Expressions.InvocationExpression"/> (for a delegate invocation). + </summary> + </member> + <member name="M:Moq.Extensions.IsDelegate(System.Type)"> + <summary> + Tests if a type is a delegate type (subclasses <see cref="T:System.Delegate"/>). + </summary> + </member> + <member name="T:Moq.Evaluator"> + <summary> + Provides partial evaluation of subtrees, whenever they can be evaluated locally. + </summary> + <author>Matt Warren: http://blogs.msdn.com/mattwar</author> + <contributor>Documented by InSTEDD: http://www.instedd.org</contributor> + </member> + <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression,System.Func{System.Linq.Expressions.Expression,System.Boolean})"> + <summary> + Performs evaluation and replacement of independent sub-trees + </summary> + <param name="expression">The root of the expression tree.</param> + <param name="fnCanBeEvaluated">A function that decides whether a given expression + node can be part of the local function.</param> + <returns>A new tree with sub-trees evaluated and replaced.</returns> + </member> + <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression)"> + <summary> + Performs evaluation and replacement of independent sub-trees + </summary> + <param name="expression">The root of the expression tree.</param> + <returns>A new tree with sub-trees evaluated and replaced.</returns> + </member> + <member name="T:Moq.Evaluator.SubtreeEvaluator"> + <summary> + Evaluates and replaces sub-trees when first candidate is reached (top-down) + </summary> + </member> + <member name="T:Moq.Evaluator.Nominator"> + <summary> + Performs bottom-up analysis to determine which nodes can possibly + be part of an evaluated sub-tree. + </summary> + </member> + <member name="M:Moq.Guard.NotNull``1(System.Linq.Expressions.Expression{System.Func{``0}},``0)"> + <summary> + Ensures the given <paramref name="value"/> is not null. + Throws <see cref="T:System.ArgumentNullException"/> otherwise. + </summary> + </member> + <member name="M:Moq.Guard.NotNullOrEmpty(System.Linq.Expressions.Expression{System.Func{System.String}},System.String)"> + <summary> + Ensures the given string <paramref name="value"/> is not null or empty. + Throws <see cref="T:System.ArgumentNullException"/> in the first case, or + <see cref="T:System.ArgumentException"/> in the latter. + </summary> + </member> + <member name="M:Moq.Guard.NotOutOfRangeInclusive``1(System.Linq.Expressions.Expression{System.Func{``0}},``0,``0,``0)"> + <summary> + Checks an argument to ensure it is in the specified range including the edges. + </summary> + <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type. + </typeparam> + <param name="reference">The expression containing the name of the argument.</param> + <param name="value">The argument value to check.</param> + <param name="from">The minimun allowed value for the argument.</param> + <param name="to">The maximun allowed value for the argument.</param> + </member> + <member name="M:Moq.Guard.NotOutOfRangeExclusive``1(System.Linq.Expressions.Expression{System.Func{``0}},``0,``0,``0)"> + <summary> + Checks an argument to ensure it is in the specified range excluding the edges. + </summary> + <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type. + </typeparam> + <param name="reference">The expression containing the name of the argument.</param> + <param name="value">The argument value to check.</param> + <param name="from">The minimun allowed value for the argument.</param> + <param name="to">The maximun allowed value for the argument.</param> + </member> + <member name="T:Moq.IMocked`1"> + <summary> + Implemented by all generated mock object instances. + </summary> + </member> + <member name="T:Moq.IMocked"> + <summary> + Implemented by all generated mock object instances. + </summary> + </member> + <member name="P:Moq.IMocked.Mock"> + <summary> + Reference the Mock that contains this as the <c>mock.Object</c> value. + </summary> + </member> + <member name="P:Moq.IMocked`1.Mock"> + <summary> + Reference the Mock that contains this as the <c>mock.Object</c> value. + </summary> + </member> + <member name="T:Moq.Interceptor"> + <summary> + Implements the actual interception and method invocation for + all mocks. + </summary> + </member> + <member name="T:Moq.Language.Flow.ISetupSetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallbackSetter`1"> + <summary> + Defines the <c>Callback</c> verb for property setter setups. + </summary> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.ICallbackSetter`1.Callback(System.Action{`0})"> + <summary> + Specifies a callback to invoke when the property is set that receives the + property value being set. + </summary> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the property value being set. + <code> + mock.SetupSet(x => x.Suspended) + .Callback((bool state) => Console.WriteLine(state)); + </code> + </example> + </member> + <member name="T:Moq.It"> + <summary> + Allows the specification of a matching condition for an + argument in a method invocation, rather than a specific + argument value. "It" refers to the argument being matched. + </summary><remarks> + This class allows the setup to match a method invocation + with an arbitrary value, with a value in a specified range, or + even one that matches a given predicate. + </remarks> + </member> + <member name="M:Moq.It.IsAny``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type. + </summary><remarks> + Typically used when the actual argument value for a method + call is not relevant. + </remarks><example> + <code> + // Throws an exception for a call to Remove with any string value. + mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); + </code> + </example><typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.It.IsNotNull``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type, except null. + </summary><typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.It.Is``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Matches any value that satisfies the given predicate. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="match">The predicate used to match the method argument.</param><remarks> + Allows the specification of a predicate to perform matching + of method call arguments. + </remarks><example> + This example shows how to return the value <c>1</c> whenever the argument to the + <c>Do</c> method is an even number. + <code> + mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) + .Returns(1); + </code> + This example shows how to throw an exception if the argument to the + method is a negative number: + <code> + mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)"> + <summary> + Matches any value that is in the range specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="from">The lower bound of the range.</param><param name="to">The upper bound of the range.</param><param name="rangeKind"> + The kind of range. See <see cref="T:Moq.Range"/>. + </param><example> + The following example shows how to expect a method call + with an integer argument within the 0..100 range. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsInRange(0, 100, Range.Inclusive))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsIn``1(System.Collections.Generic.IEnumerable{``0})"> + <summary> + Matches any value that is present in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of possible values.</param><example> + The following example shows how to expect a method call + with an integer argument with value from a list. + <code> + var values = new List<int> { 1, 2, 3 }; + + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsIn(values))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsIn``1(``0[])"> + <summary> + Matches any value that is present in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of possible values.</param><example> + The following example shows how to expect a method call + with an integer argument with a value of 1, 2, or 3. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsIn(1, 2, 3))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsNotIn``1(System.Collections.Generic.IEnumerable{``0})"> + <summary> + Matches any value that is not found in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of disallowed values.</param><example> + The following example shows how to expect a method call + with an integer argument with value not found from a list. + <code> + var values = new List<int> { 1, 2, 3 }; + + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsNotIn(values))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsNotIn``1(``0[])"> + <summary> + Matches any value that is not found in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of disallowed values.</param><example> + The following example shows how to expect a method call + with an integer argument of any value except 1, 2, or 3. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsNotIn(1, 2, 3))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsRegex(System.String)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary><param name="regex">The pattern to use to match the string argument value.</param><example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression: + <code> + mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); + </code> + </example> + </member> + <member name="M:Moq.It.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary><param name="regex">The pattern to use to match the string argument value.</param><param name="options">The options used to interpret the pattern.</param><example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression, in a case insensitive way: + <code> + mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); + </code> + </example> + </member> + <member name="T:Moq.Matchers.MatcherAttributeMatcher"> + <summary> + Matcher to treat static functions as matchers. + + mock.Setup(x => x.StringMethod(A.MagicString())); + + public static class A + { + [Matcher] + public static string MagicString() { return null; } + public static bool MagicString(string arg) + { + return arg == "magic"; + } + } + + Will succeed if: mock.Object.StringMethod("magic"); + and fail with any other call. + </summary> + </member> + <member name="T:Moq.MockBehavior"> + <summary> + Options to customize the behavior of the mock. + </summary> + </member> + <member name="F:Moq.MockBehavior.Strict"> + <summary> + Causes the mock to always throw + an exception for invocations that don't have a + corresponding setup. + </summary> + </member> + <member name="F:Moq.MockBehavior.Loose"> + <summary> + Will never throw exceptions, returning default + values when necessary (null for reference types, + zero for value types or empty enumerables and arrays). + </summary> + </member> + <member name="F:Moq.MockBehavior.Default"> + <summary> + Default mock behavior, which equals <see cref="F:Moq.MockBehavior.Loose"/>. + </summary> + </member> + <member name="T:Moq.MockException"> + <summary> + Exception thrown by mocks when setups are not matched, + the mock is not properly setup, etc. + </summary> + <remarks> + A distinct exception type is provided so that exceptions + thrown by the mock can be differentiated in tests that + expect other exceptions to be thrown (i.e. ArgumentException). + <para> + Richer exception hierarchy/types are not provided as + tests typically should <b>not</b> catch or expect exceptions + from the mocks. These are typically the result of changes + in the tested class or its collaborators implementation, and + result in fixes in the mock setup so that they dissapear and + allow the test to pass. + </para> + </remarks> + </member> + <member name="M:Moq.MockException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Supports the serialization infrastructure. + </summary> + <param name="info">Serialization information.</param> + <param name="context">Streaming context.</param> + </member> + <member name="M:Moq.MockException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Supports the serialization infrastructure. + </summary> + <param name="info">Serialization information.</param> + <param name="context">Streaming context.</param> + </member> + <member name="P:Moq.MockException.IsVerificationError"> + <summary> + Indicates whether this exception is a verification fault raised by Verify() + </summary> + </member> + <member name="T:Moq.MockException.ExceptionReason"> + <summary> + Made internal as it's of no use for + consumers, but it's important for + our own tests. + </summary> + </member> + <member name="T:Moq.MockVerificationException"> + <devdoc> + Used by the mock factory to accumulate verification + failures. + </devdoc> + </member> + <member name="M:Moq.MockVerificationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Supports the serialization infrastructure. + </summary> + </member> + <member name="T:Moq.Properties.Resources"> + <summary> + A strongly-typed resource class, for looking up localized strings, etc. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ResourceManager"> + <summary> + Returns the cached ResourceManager instance used by this class. + </summary> + </member> + <member name="P:Moq.Properties.Resources.Culture"> + <summary> + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + </summary> + </member> + <member name="P:Moq.Properties.Resources.AlreadyInitialized"> + <summary> + Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ArgumentCannotBeEmpty"> + <summary> + Looks up a localized string similar to Value cannot be an empty string.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.AsMustBeInterface"> + <summary> + Looks up a localized string similar to Can only add interfaces to the mock.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.CantSetReturnValueForVoid"> + <summary> + Looks up a localized string similar to Can't set return value for void method {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorArgsForDelegate"> + <summary> + Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorArgsForInterface"> + <summary> + Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorNotFound"> + <summary> + Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.EventNofFound"> + <summary> + Looks up a localized string similar to Could not locate event for attach or detach method {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.FieldsNotSupported"> + <summary> + Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.InvalidMockClass"> + <summary> + Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . + </summary> + </member> + <member name="P:Moq.Properties.Resources.InvalidMockGetType"> + <summary> + Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. + Please cast the argument to one of the supported types: {1}. + Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqBinaryOperatorNotSupported"> + <summary> + Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqMethodNotSupported"> + <summary> + Looks up a localized string similar to LINQ method '{0}' not supported.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqMethodNotVirtual"> + <summary> + Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MemberMissing"> + <summary> + Looks up a localized string similar to Member {0}.{1} does not exist.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MethodIsPublic"> + <summary> + Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: + mock.Setup(x => x.{1}()); + . + </summary> + </member> + <member name="P:Moq.Properties.Resources.MockExceptionMessage"> + <summary> + Looks up a localized string similar to {0} invocation failed with mock behavior {1}. + {2}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MoreThanNCalls"> + <summary> + Looks up a localized string similar to Expected only {0} calls to {1}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MoreThanOneCall"> + <summary> + Looks up a localized string similar to Expected only one call to {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeast"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at least {2} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeastOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at least once, but was never performed: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMost"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at most {3} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMostOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at most once, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenExclusive"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenInclusive"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsExactly"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock exactly {2} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsNever"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock should never have been performed, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock once, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoSetup"> + <summary> + Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ObjectInstanceNotMock"> + <summary> + Looks up a localized string similar to Object instance was not created by Moq.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.OutExpressionMustBeConstantValue"> + <summary> + Looks up a localized string similar to Out expression must evaluate to a constant value.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyGetNotFound"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not have a getter.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyMissing"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not exist.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyNotReadable"> + <summary> + Looks up a localized string similar to Property {0}.{1} is write-only.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyNotWritable"> + <summary> + Looks up a localized string similar to Property {0}.{1} is read-only.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertySetNotFound"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not have a setter.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.RaisedUnassociatedEvent"> + <summary> + Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.RefExpressionMustBeConstantValue"> + <summary> + Looks up a localized string similar to Ref expression must evaluate to a constant value.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ReturnValueRequired"> + <summary> + Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupLambda"> + <summary> + Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNever"> + <summary> + Looks up a localized string similar to Invocation {0} should not have been made.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotMethod"> + <summary> + Looks up a localized string similar to Expression is not a method invocation: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotProperty"> + <summary> + Looks up a localized string similar to Expression is not a property access: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotSetter"> + <summary> + Looks up a localized string similar to Expression is not a property setter invocation.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupOnNonMemberMethod"> + <summary> + Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupOnNonOverridableMember"> + <summary> + Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.TypeNotImplementInterface"> + <summary> + Looks up a localized string similar to Type {0} does not implement required interface {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.TypeNotInheritFromType"> + <summary> + Looks up a localized string similar to Type {0} does not from required type {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnexpectedPublicProperty"> + <summary> + Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: + mock.Setup(x => x.{1}).Returns(value); + mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one + mock.SetupSet(x => x.{1}).Callback(callbackDelegate); + . + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedExpression"> + <summary> + Looks up a localized string similar to Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedIntermediateExpression"> + <summary> + Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedIntermediateType"> + <summary> + Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedMatcherParamsForSetter"> + <summary> + Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedMember"> + <summary> + Looks up a localized string similar to Member {0} is not supported for protected mocking.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedNonStaticMatcherForSetter"> + <summary> + Looks up a localized string similar to Setter expression can only use static custom matchers.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.VerficationFailed"> + <summary> + Looks up a localized string similar to The following setups were not matched: + {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.VerifyOnNonVirtualMember"> + <summary> + Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. + </summary> + </member> + <member name="T:Moq.Protected.IProtectedMock`1"> + <summary> + Allows setups to be specified for protected members by using their + name as a string, rather than strong-typing them which is not possible + due to their visibility. + </summary> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Setup(System.String,System.Object[])"> + <summary> + Specifies a setup for a void method invocation with the given + <paramref name="voidMethodName"/>, optionally specifying arguments for the method call. + </summary> + <param name="voidMethodName">The name of the void method to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Setup``1(System.String,System.Object[])"> + <summary> + Specifies a setup for an invocation on a property or a non void method with the given + <paramref name="methodOrPropertyName"/>, optionally specifying arguments for the method call. + </summary> + <param name="methodOrPropertyName">The name of the method or property to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <typeparam name="TResult">The return type of the method or property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.SetupGet``1(System.String)"> + <summary> + Specifies a setup for an invocation on a property getter with the given + <paramref name="propertyName"/>. + </summary> + <param name="propertyName">The name of the property.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.SetupSet``1(System.String,System.Object)"> + <summary> + Specifies a setup for an invocation on a property setter with the given + <paramref name="propertyName"/>. + </summary> + <param name="propertyName">The name of the property.</param> + <param name="value">The property value. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Verify(System.String,Moq.Times,System.Object[])"> + <summary> + Specifies a verify for a void method with the given <paramref name="methodName"/>, + optionally specifying arguments for the method call. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="methodName">The name of the void method to be verified.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Verify``1(System.String,Moq.Times,System.Object[])"> + <summary> + Specifies a verify for an invocation on a property or a non void method with the given + <paramref name="methodName"/>, optionally specifying arguments for the method call. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="methodName">The name of the method or property to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <typeparam name="TResult">The type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.VerifyGet``1(System.String,Moq.Times)"> + <summary> + Specifies a verify for an invocation on a property getter with the given + <paramref name="propertyName"/>. + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + </summary> + <param name="propertyName">The name of the property.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.VerifySet``1(System.String,Moq.Times,System.Object)"> + <summary> + Specifies a setup for an invocation on a property setter with the given + <paramref name="propertyName"/>. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="propertyName">The name of the property.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="value">The property value.</param> + <typeparam name="TProperty">The type of the property. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</typeparam> + </member> + <member name="T:Moq.Protected.ItExpr"> + <summary> + Allows the specification of a matching condition for an + argument in a protected member setup, rather than a specific + argument value. "ItExpr" refers to the argument being matched. + </summary> + <remarks> + <para>Use this variant of argument matching instead of + <see cref="T:Moq.It"/> for protected setups.</para> + This class allows the setup to match a method invocation + with an arbitrary value, with a value in a specified range, or + even one that matches a given predicate, or null. + </remarks> + </member> + <member name="M:Moq.Protected.ItExpr.IsNull``1"> + <summary> + Matches a null value of the given <typeparamref name="TValue"/> type. + </summary> + <remarks> + Required for protected mocks as the null value cannot be used + directly as it prevents proper method overload selection. + </remarks> + <example> + <code> + // Throws an exception for a call to Remove with a null string value. + mock.Protected() + .Setup("Remove", ItExpr.IsNull<string>()) + .Throws(new InvalidOperationException()); + </code> + </example> + <typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.Protected.ItExpr.IsAny``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type. + </summary> + <remarks> + Typically used when the actual argument value for a method + call is not relevant. + </remarks> + <example> + <code> + // Throws an exception for a call to Remove with any string value. + mock.Protected() + .Setup("Remove", ItExpr.IsAny<string>()) + .Throws(new InvalidOperationException()); + </code> + </example> + <typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.Protected.ItExpr.Is``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Matches any value that satisfies the given predicate. + </summary> + <typeparam name="TValue">Type of the argument to check.</typeparam> + <param name="match">The predicate used to match the method argument.</param> + <remarks> + Allows the specification of a predicate to perform matching + of method call arguments. + </remarks> + <example> + This example shows how to return the value <c>1</c> whenever the argument to the + <c>Do</c> method is an even number. + <code> + mock.Protected() + .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) + .Returns(1); + </code> + This example shows how to throw an exception if the argument to the + method is a negative number: + <code> + mock.Protected() + .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsInRange``1(``0,``0,Moq.Range)"> + <summary> + Matches any value that is in the range specified. + </summary> + <typeparam name="TValue">Type of the argument to check.</typeparam> + <param name="from">The lower bound of the range.</param> + <param name="to">The upper bound of the range.</param> + <param name="rangeKind">The kind of range. See <see cref="T:Moq.Range"/>.</param> + <example> + The following example shows how to expect a method call + with an integer argument within the 0..100 range. + <code> + mock.Protected() + .Setup("HasInventory", + ItExpr.IsAny<string>(), + ItExpr.IsInRange(0, 100, Range.Inclusive)) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsRegex(System.String)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary> + <param name="regex">The pattern to use to match the string argument value.</param> + <example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression: + <code> + mock.Protected() + .Setup("Check", ItExpr.IsRegex("[a-z]+")) + .Returns(1); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary> + <param name="regex">The pattern to use to match the string argument value.</param> + <param name="options">The options used to interpret the pattern.</param> + <example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression, in a case insensitive way: + <code> + mock.Protected() + .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) + .Returns(1); + </code> + </example> + </member> + <member name="T:Moq.Protected.ProtectedExtension"> + <summary> + Enables the <c>Protected()</c> method on <see cref="T:Moq.Mock`1"/>, + allowing setups to be set for protected members by using their + name as a string, rather than strong-typing them which is not possible + due to their visibility. + </summary> + </member> + <member name="M:Moq.Protected.ProtectedExtension.Protected``1(Moq.Mock{``0})"> + <summary> + Enable protected setups for the mock. + </summary> + <typeparam name="T">Mocked object type. Typically omitted as it can be inferred from the mock instance.</typeparam> + <param name="mock">The mock to set the protected setups on.</param> + </member> + <member name="T:ThisAssembly"> + <group name="overview" title="Overview" order="0" /> + <group name="setups" title="Specifying setups" order="1" /> + <group name="returns" title="Returning values from members" order="2" /> + <group name="verification" title="Verifying setups" order="3" /> + <group name="advanced" title="Advanced scenarios" order="99" /> + <group name="factory" title="Using MockFactory for consistency across mocks" order="4" /> + </member> + <member name="T:Moq.Range"> + <summary> + Kind of range to use in a filter specified through + <see cref="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)"/>. + </summary> + </member> + <member name="F:Moq.Range.Inclusive"> + <summary> + The range includes the <c>to</c> and + <c>from</c> values. + </summary> + </member> + <member name="F:Moq.Range.Exclusive"> + <summary> + The range does not include the <c>to</c> and + <c>from</c> values. + </summary> + </member> + <member name="T:Moq.DefaultValue"> + <summary> + Determines the way default values are generated + calculated for loose mocks. + </summary> + </member> + <member name="F:Moq.DefaultValue.Empty"> + <summary> + Default behavior, which generates empty values for + value types (i.e. default(int)), empty array and + enumerables, and nulls for all other reference types. + </summary> + </member> + <member name="F:Moq.DefaultValue.Mock"> + <summary> + Whenever the default value generated by <see cref="F:Moq.DefaultValue.Empty"/> + is null, replaces this value with a mock (if the type + can be mocked). + </summary> + <remarks> + For sealed classes, a null value will be generated. + </remarks> + </member> + <member name="T:Moq.Linq.MockQueryable`1"> + <summary> + A default implementation of IQueryable for use with QueryProvider + </summary> + </member> + <member name="M:Moq.Linq.MockQueryable`1.#ctor(System.Linq.Expressions.MethodCallExpression)"> + <summary> + The <paramref name="underlyingCreateMocks"/> is a + static method that returns an IQueryable of Mocks of T which is used to + apply the linq specification to. + </summary> + </member> + <member name="T:Moq.Match"> + <summary> + Allows creation custom value matchers that can be used on setups and verification, + completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary><remarks> + See also <see cref="T:Moq.Match`1"/>. + </remarks> + </member> + <member name="M:Moq.Match.Matcher``1"> + <devdoc> + Provided for the sole purpose of rendering the delegate passed to the + matcher constructor if no friendly render lambda is provided. + </devdoc> + </member> + <member name="M:Moq.Match.Create``1(System.Predicate{``0})"> + <summary> + Initializes the match with the condition that + will be checked in order to match invocation + values. + </summary><param name="condition">The condition to match against actual values.</param><remarks> + <seealso cref="T:Moq.Match`1"/> + </remarks> + </member> + <member name="M:Moq.Match.Create``1(System.Predicate{``0},System.Linq.Expressions.Expression{System.Func{``0}})"> + <!-- No matching elements were found for the following include tag --><include file="Match.xdoc" path="docs/doc[@for="Match.Create{T}(condition,renderExpression"]/*"/> + </member> + <member name="M:Moq.Match.SetLastMatch``1(Moq.Match{``0})"> + <devdoc> + This method is used to set an expression as the last matcher invoked, + which is used in the SetupSet to allow matchers in the prop = value + delegate expression. This delegate is executed in "fluent" mode in + order to capture the value being set, and construct the corresponding + methodcall. + This is also used in the MatcherFactory for each argument expression. + This method ensures that when we execute the delegate, we + also track the matcher that was invoked, so that when we create the + methodcall we build the expression using it, rather than the null/default + value returned from the actual invocation. + </devdoc> + </member> + <member name="T:Moq.Match`1"> + <summary> + Allows creation custom value matchers that can be used on setups and verification, + completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary><typeparam name="T">Type of the value to match.</typeparam><remarks> + The argument matching is used to determine whether a concrete + invocation in the mock matches a given setup. This + matching mechanism is fully extensible. + </remarks><example> + Creating a custom matcher is straightforward. You just need to create a method + that returns a value from a call to <see cref="M:Moq.Match.Create``1(System.Predicate{``0})"/> with + your matching condition and optional friendly render expression: + <code> + [Matcher] + public Order IsBigOrder() + { + return Match<Order>.Create( + o => o.GrandTotal >= 5000, + /* a friendly expression to render on failures */ + () => IsBigOrder()); + } + </code> + This method can be used in any mock setup invocation: + <code> + mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); + </code> + At runtime, Moq knows that the return value was a matcher (note that the method MUST be + annotated with the [Matcher] attribute in order to determine this) and + evaluates your predicate with the actual value passed into your predicate. + <para> + Another example might be a case where you want to match a lists of orders + that contains a particular one. You might create matcher like the following: + </para> + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); + } + } + </code> + Now we can invoke this static method instead of an argument in an + invocation: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + </code> + </example> + </member> + <member name="T:Moq.FluentMockContext"> + <summary> + Tracks the current mock and interception context. + </summary> + </member> + <member name="P:Moq.FluentMockContext.IsActive"> + <summary> + Having an active fluent mock context means that the invocation + is being performed in "trial" mode, just to gather the + target method and arguments that need to be matched later + when the actual invocation is made. + </summary> + </member> + <member name="T:Moq.MockDefaultValueProvider"> + <summary> + A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value + for non-mockeable types, and mocks for all other types (interfaces and + non-sealed classes) that can be mocked. + </summary> + </member> + <member name="T:Moq.Mocks"> + <summary> + Allows querying the universe of mocks for those that behave + according to the LINQ query specification. + </summary> + <devdoc> + This entry-point into Linq to Mocks is the only one in the root Moq + namespace to ease discovery. But to get all the mocking extension + methods on Object, a using of Moq.Linq must be done, so that the + polluting of the intellisense for all objects is an explicit opt-in. + </devdoc> + </member> + <member name="M:Moq.Mocks.Of``1"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.Mocks.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.Mocks.OneOf``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mocks.OneOf``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mocks.CreateMockQuery``1"> + <summary> + Creates the mock query with the underlying queriable implementation. + </summary> + </member> + <member name="M:Moq.Mocks.CreateQueryable``1"> + <summary> + Wraps the enumerator inside a queryable. + </summary> + </member> + <member name="M:Moq.Mocks.CreateMocks``1"> + <summary> + Method that is turned into the actual call from .Query{T}, to + transform the queryable query into a normal enumerable query. + This method is never used directly by consumers. + </summary> + </member> + <member name="M:Moq.Mocks.SetPropery``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Extension method used to support Linq-like setup properties that are not virtual but do have + a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) + </summary> + </member> + <member name="T:Moq.QueryableMockExtensions"> + <summary> + Helper extensions that are used by the query translator. + </summary> + </member> + <member name="M:Moq.QueryableMockExtensions.FluentMock``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Retrieves a fluent mock from the given setup expression. + </summary> + </member> + <member name="M:Moq.Proxy.IProxyFactory.GetDelegateProxyInterface(System.Type,System.Reflection.MethodInfo@)"> + <summary> + Gets an autogenerated interface with a method on it that matches the signature of the specified + <paramref name="delegateType"/>. + </summary> + <remarks> + Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. + This is how we support delegate mocking. The factory caches such interfaces and reuses them + for repeated requests for the same delegate type. + </remarks> + <param name="delegateType">The delegate type for which an interface is required.</param> + <param name="delegateInterfaceMethod">The method on the autogenerated interface.</param> + </member> + <member name="M:Moq.Proxy.CastleProxyFactory.CreateProxy(System.Type,Moq.Proxy.ICallInterceptor,System.Type[],System.Object[])"> + <inheritdoc /> + </member> + <member name="M:Moq.Proxy.CastleProxyFactory.GetDelegateProxyInterface(System.Type,System.Reflection.MethodInfo@)"> + <inheritdoc /> + </member> + <member name="T:Moq.Times"> + <summary> + Defines the number of invocations allowed by a mocked method. + </summary> + </member> + <member name="M:Moq.Times.AtLeast(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked <paramref name="callCount"/> times as minimum. + </summary><param name="callCount">The minimun number of times.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtLeastOnce"> + <summary> + Specifies that a mocked method should be invoked one time as minimum. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtMost(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked <paramref name="callCount"/> time as maximun. + </summary><param name="callCount">The maximun number of times.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtMostOnce"> + <summary> + Specifies that a mocked method should be invoked one time as maximun. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Between(System.Int32,System.Int32,Moq.Range)"> + <summary> + Specifies that a mocked method should be invoked between <paramref name="callCountFrom"/> and + <paramref name="callCountTo"/> times. + </summary><param name="callCountFrom">The minimun number of times.</param><param name="callCountTo">The maximun number of times.</param><param name="rangeKind"> + The kind of range. See <see cref="T:Moq.Range"/>. + </param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Exactly(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked exactly <paramref name="callCount"/> times. + </summary><param name="callCount">The times that a method or property can be called.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Never"> + <summary> + Specifies that a mocked method should not be invoked. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Once"> + <summary> + Specifies that a mocked method should be invoked exactly one time. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Equals(System.Object)"> + <summary> + Determines whether the specified <see cref="T:System.Object"/> is equal to this instance. + </summary><param name="obj"> + The <see cref="T:System.Object"/> to compare with this instance. + </param><returns> + <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>. + </returns> + </member> + <member name="M:Moq.Times.GetHashCode"> + <summary> + Returns a hash code for this instance. + </summary><returns> + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + </returns> + </member> + <member name="M:Moq.Times.op_Equality(Moq.Times,Moq.Times)"> + <summary> + Determines whether two specified <see cref="T:Moq.Times"/> objects have the same value. + </summary><param name="left"> + The first <see cref="T:Moq.Times"/>. + </param><param name="right"> + The second <see cref="T:Moq.Times"/>. + </param><returns> + <c>true</c> if the value of left is the same as the value of right; otherwise, <c>false</c>. + </returns> + </member> + <member name="M:Moq.Times.op_Inequality(Moq.Times,Moq.Times)"> + <summary> + Determines whether two specified <see cref="T:Moq.Times"/> objects have different values. + </summary><param name="left"> + The first <see cref="T:Moq.Times"/>. + </param><param name="right"> + The second <see cref="T:Moq.Times"/>. + </param><returns> + <c>true</c> if the value of left is different from the value of right; otherwise, <c>false</c>. + </returns> + </member> + </members> +</doc>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Moq.4.1.1309.1617/lib/net40/Moq.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,5386 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>Moq</name> + </assembly> + <members> + <member name="T:Moq.Language.ISetupConditionResult`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.Setup(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + The expectation will be considered only in the former condition. + </summary> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.Setup``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + The expectation will be considered only in the former condition. + </summary> + <typeparam name="TResult"></typeparam> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Setups the get. + </summary> + <typeparam name="TProperty">The type of the property.</typeparam> + <param name="expression">The expression.</param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupSet``1(System.Action{`0})"> + <summary> + Setups the set. + </summary> + <typeparam name="TProperty">The type of the property.</typeparam> + <param name="setterExpression">The setter expression.</param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupSet(System.Action{`0})"> + <summary> + Setups the set. + </summary> + <param name="setterExpression">The setter expression.</param> + <returns></returns> + </member> + <member name="M:Moq.IInterceptStrategy.HandleIntercept(Moq.Proxy.ICallContext,Moq.InterceptStrategyContext)"> + <summary> + Handle interception + </summary> + <param name="invocation">the current invocation context</param> + <param name="ctx">shared data among the strategies during an interception</param> + <returns>true if further interception has to be processed, otherwise false</returns> + </member> + <member name="T:Moq.IMock`1"> + <summary> + Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> + are possible. Only covers the covariant members of Mock<T>. + </summary> + </member> + <member name="P:Moq.IMock`1.Object"> + <summary> + Exposes the mocked object instance. + </summary> + </member> + <member name="P:Moq.IMock`1.Behavior"> + <summary> + Behavior of the mock, according to the value set in the constructor. + </summary> + </member> + <member name="P:Moq.IMock`1.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.IMock`1.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="M:Moq.AddActualInvocation.GetEventFromName(System.String)"> + <summary> + Get an eventInfo for a given event name. Search type ancestors depth first if necessary. + </summary> + <param name="eventName">Name of the event, with the set_ or get_ prefix already removed</param> + </member> + <member name="M:Moq.AddActualInvocation.GetNonPublicEventFromName(System.String)"> + <summary> + Get an eventInfo for a given event name. Search type ancestors depth first if necessary. + Searches also in non public events. + </summary> + <param name="eventName">Name of the event, with the set_ or get_ prefix already removed</param> + </member> + <member name="M:Moq.AddActualInvocation.GetAncestorTypes(System.Type)"> + <summary> + Given a type return all of its ancestors, both types and interfaces. + </summary> + <param name="initialType">The type to find immediate ancestors of</param> + </member> + <member name="T:Moq.Language.ICallback"> + <summary> + Defines the <c>Callback</c> verb and overloads. + </summary> + </member> + <member name="T:Moq.IHideObjectMembers"> + <summary> + Helper interface used to hide the base <see cref="T:System.Object"/> + members from the fluent API to make it much cleaner + in Visual Studio intellisense. + </summary> + </member> + <member name="M:Moq.IHideObjectMembers.GetType"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.GetHashCode"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.ToString"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.Equals(System.Object)"> + <summary/> + </member> + <member name="M:Moq.Language.ICallback.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the method is called. + </summary> + <param name="action">The callback method to invoke.</param> + <example> + The following example specifies a callback to set a boolean + value that can be used later: + <code> + var called = false; + mock.Setup(x => x.Execute()) + .Callback(() => called = true); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``1(System.Action{``0})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T">The argument type of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <example> + Invokes the given callback with the concrete invocation argument value. + <para> + Notice how the specific string argument is retrieved by simply declaring + it as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Callback((string command) => Console.WriteLine(command)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``2(System.Action{``0,``1})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``3(System.Action{``0,``1,``2})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``4(System.Action{``0,``1,``2,``3})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``5(System.Action{``0,``1,``2,``3,``4})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``6(System.Action{``0,``1,``2,``3,``4,``5})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``7(System.Action{``0,``1,``2,``3,``4,``5,``6})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``8(System.Action{``0,``1,``2,``3,``4,``5,``6,``7})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``9(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``10(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``11(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``12(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``13(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``14(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``15(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``16(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); + </code> + </example> + </member> + <member name="T:Moq.Language.ICallback`2"> + <summary> + Defines the <c>Callback</c> verb and overloads for callbacks on + setups that return a value. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TResult">Type of the return value of the setup.</typeparam> + </member> + <member name="M:Moq.Language.ICallback`2.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the method is called. + </summary> + <param name="action">The callback method to invoke.</param> + <example> + The following example specifies a callback to set a boolean value that can be used later: + <code> + var called = false; + mock.Setup(x => x.Execute()) + .Callback(() => called = true) + .Returns(true); + </code> + Note that in the case of value-returning methods, after the <c>Callback</c> + call you can still specify the return value. + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``1(System.Action{``0})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T">The type of the argument of the invoked method.</typeparam> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the concrete invocation argument value. + <para> + Notice how the specific string argument is retrieved by simply declaring + it as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Callback(command => Console.WriteLine(command)) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``2(System.Action{``0,``1})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``3(System.Action{``0,``1,``2})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``4(System.Action{``0,``1,``2,``3})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``5(System.Action{``0,``1,``2,``3,``4})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``6(System.Action{``0,``1,``2,``3,``4,``5})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``7(System.Action{``0,``1,``2,``3,``4,``5,``6})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``8(System.Action{``0,``1,``2,``3,``4,``5,``6,``7})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``9(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``10(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``11(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``12(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``13(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``14(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``15(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``16(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); + </code> + </example> + </member> + <member name="T:Moq.Language.IRaise`1"> + <summary> + Defines the <c>Raises</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"> + <summary> + Specifies the event that will be raised + when the setup is met. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="args">The event arguments to pass for the raised event.</param> + <example> + The following example shows how to raise an event when + the setup is met: + <code> + var mock = new Mock<IContainer>(); + + mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) + .Raises(add => add.Added += null, EventArgs.Empty); + </code> + </example> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Func{System.EventArgs})"> + <summary> + Specifies the event that will be raised + when the setup is matched. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="func">A function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Object[])"> + <summary> + Specifies the custom event that will be raised + when the setup is matched. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="args">The arguments to pass to the custom delegate (non EventHandler-compatible).</param> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``1(System.Action{`0},System.Func{``0,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``2(System.Action{`0},System.Func{``0,``1,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``3(System.Action{`0},System.Func{``0,``1,``2,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``4(System.Action{`0},System.Func{``0,``1,``2,``3,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``5(System.Action{`0},System.Func{``0,``1,``2,``3,``4,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``6(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``7(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``8(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``9(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``10(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``11(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``12(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``13(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``14(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``15(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <typeparam name="T15">The type of the fifteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``16(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <typeparam name="T15">The type of the fifteenth argument received by the expected invocation.</typeparam> + <typeparam name="T16">The type of the sixteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="T:Moq.Language.IReturns`2"> + <summary> + Defines the <c>Returns</c> verb. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TResult">Type of the return value from the expression.</typeparam> + </member> + <member name="M:Moq.Language.IReturns`2.Returns(`1)"> + <summary> + Specifies the value to return. + </summary> + <param name="value">The value to return, or <see langword="null"/>.</param> + <example> + Return a <c>true</c> value from the method call: + <code> + mock.Setup(x => x.Execute("ping")) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns(System.Func{`1})"> + <summary> + Specifies a function that will calculate the value to return from the method. + </summary> + <param name="valueFunction">The function that will calculate the return value.</param> + <example group="returns"> + Return a calculated value when the method is called: + <code> + mock.Setup(x => x.Execute("ping")) + .Returns(() => returnValues[0]); + </code> + The lambda expression to retrieve the return value is lazy-executed, + meaning that its value may change depending on the moment the method + is executed and the value the <c>returnValues</c> array has at + that moment. + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``1(System.Func{``0,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T">The type of the argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <example group="returns"> + Return a calculated value which is evaluated lazily at the time of the invocation. + <para> + The lookup list can change between invocations and the setup + will return different values accordingly. Also, notice how the specific + string argument is retrieved by simply declaring it as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Returns((string command) => returnValues[command]); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.CallBase"> + <summary> + Calls the real method of the object and returns its return value. + </summary> + <returns>The value calculated by the real method of the object.</returns> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``2(System.Func{``0,``1,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2) => arg1 + arg2); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``3(System.Func{``0,``1,``2,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``4(System.Func{``0,``1,``2,``3,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``5(System.Func{``0,``1,``2,``3,``4,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``6(System.Func{``0,``1,``2,``3,``4,``5,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``7(System.Func{``0,``1,``2,``3,``4,``5,``6,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``8(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``9(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``10(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``11(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``12(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``13(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``14(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``15(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``16(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); + </code> + </example> + </member> + <member name="T:Moq.Language.ISetupSequentialResult`1"> + <summary> + Language for ReturnSequence + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Returns(`0)"> + <summary> + Returns value + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Throws(System.Exception)"> + <summary> + Throws an exception + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Throws``1"> + <summary> + Throws an exception + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.CallBase"> + <summary> + Calls original method + </summary> + </member> + <member name="F:Moq.Linq.FluentMockVisitor.isFirst"> + <summary> + The first method call or member access will be the + last segment of the expression (depth-first traversal), + which is the one we have to Setup rather than FluentMock. + And the last one is the one we have to Mock.Get rather + than FluentMock. + </summary> + </member> + <member name="T:Moq.Mock"> + <summary> + Base class for mocks and static helper class with methods that + apply to mocked objects, such as <see cref="M:Moq.Mock.Get``1(``0)"/> to + retrieve a <see cref="T:Moq.Mock`1"/> from an object instance. + </summary> + </member> + <member name="M:Moq.Mock.Of``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mock.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="predicate">The predicate with the specification of how the mocked object should behave.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mock.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:Moq.Mock"/> class. + </summary> + </member> + <member name="M:Moq.Mock.Get``1(``0)"> + <summary> + Retrieves the mock object for the given object instance. + </summary><typeparam name="T"> + Type of the mock to retrieve. Can be omitted as it's inferred + from the object instance passed in as the <paramref name="mocked"/> instance. + </typeparam><param name="mocked">The instance of the mocked object.</param><returns>The mock associated with the mocked object.</returns><exception cref="T:System.ArgumentException"> + The received <paramref name="mocked"/> instance + was not created by Moq. + </exception><example group="advanced"> + The following example shows how to add a new setup to an object + instance which is not the original <see cref="T:Moq.Mock`1"/> but rather + the object associated with it: + <code> + // Typed instance, not the mock, is retrieved from some test API. + HttpContextBase context = GetMockContext(); + + // context.Request is the typed object from the "real" API + // so in order to add a setup to it, we need to get + // the mock that "owns" it + Mock<HttpRequestBase> request = Mock.Get(context.Request); + mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) + .Returns(tempUrl); + </code> + </example> + </member> + <member name="M:Moq.Mock.OnGetObject"> + <summary> + Returns the mocked object value. + </summary> + </member> + <member name="M:Moq.Mock.Verify"> + <summary> + Verifies that all verifiable expectations have been met. + </summary><example group="verification"> + This example sets up an expectation and marks it as verifiable. After + the mock is used, a <c>Verify()</c> call is issued on the mock + to ensure the method in the setup was invoked: + <code> + var mock = new Mock<IWarehouse>(); + this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); + ... + // other test code + ... + // Will throw if the test code has didn't call HasInventory. + this.Verify(); + </code> + </example><exception cref="T:Moq.MockException">Not all verifiable expectations were met.</exception> + </member> + <member name="M:Moq.Mock.VerifyAll"> + <summary> + Verifies all expectations regardless of whether they have + been flagged as verifiable. + </summary><example group="verification"> + This example sets up an expectation without marking it as verifiable. After + the mock is used, a <see cref="M:Moq.Mock.VerifyAll"/> call is issued on the mock + to ensure that all expectations are met: + <code> + var mock = new Mock<IWarehouse>(); + this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); + ... + // other test code + ... + // Will throw if the test code has didn't call HasInventory, even + // that expectation was not marked as verifiable. + this.VerifyAll(); + </code> + </example><exception cref="T:Moq.MockException">At least one expectation was not met.</exception> + </member> + <member name="M:Moq.Mock.GetInterceptor(System.Linq.Expressions.Expression,Moq.Mock)"> + <summary> + Gets the interceptor target for the given expression and root mock, + building the intermediate hierarchy of mock objects if necessary. + </summary> + </member> + <member name="M:Moq.Mock.DoRaise(System.Reflection.EventInfo,System.EventArgs)"> + <summary> + Raises the associated event with the given + event argument data. + </summary> + </member> + <member name="M:Moq.Mock.DoRaise(System.Reflection.EventInfo,System.Object[])"> + <summary> + Raises the associated event with the given + event argument data. + </summary> + </member> + <member name="M:Moq.Mock.As``1"> + <summary> + Adds an interface implementation to the mock, + allowing setups to be specified for it. + </summary><remarks> + This method can only be called before the first use + of the mock <see cref="P:Moq.Mock.Object"/> property, at which + point the runtime type has already been generated + and no more interfaces can be added to it. + <para> + Also, <typeparamref name="TInterface"/> must be an + interface and not a class, which must be specified + when creating the mock instead. + </para> + </remarks><exception cref="T:System.InvalidOperationException"> + The mock type + has already been generated by accessing the <see cref="P:Moq.Mock.Object"/> property. + </exception><exception cref="T:System.ArgumentException"> + The <typeparamref name="TInterface"/> specified + is not an interface. + </exception><example> + The following example creates a mock for the main interface + and later adds <see cref="T:System.IDisposable"/> to it to verify + it's called by the consumer code: + <code> + var mock = new Mock<IProcessor>(); + mock.Setup(x => x.Execute("ping")); + + // add IDisposable interface + var disposable = mock.As<IDisposable>(); + disposable.Setup(d => d.Dispose()).Verifiable(); + </code> + </example><typeparam name="TInterface">Type of interface to cast the mock to.</typeparam> + </member> + <member name="M:Moq.Mock.SetReturnsDefault``1(``0)"> + <!-- No matching elements were found for the following include tag --><include file="Mock.Generic.xdoc" path="docs/doc[@for="Mock.SetReturnDefault{TReturn}"]/*"/> + </member> + <member name="P:Moq.Mock.Behavior"> + <summary> + Behavior of the mock, according to the value set in the constructor. + </summary> + </member> + <member name="P:Moq.Mock.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.Mock.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="P:Moq.Mock.Object"> + <summary> + Gets the mocked object instance. + </summary> + </member> + <member name="P:Moq.Mock.MockedType"> + <summary> + Retrieves the type of the mocked object, its generic type argument. + This is used in the auto-mocking of hierarchy access. + </summary> + </member> + <member name="P:Moq.Mock.DelegateInterfaceMethod"> + <summary> + If this is a mock of a delegate, this property contains the method + on the autogenerated interface so that we can convert setup + verify + expressions on the delegate into expressions on the interface proxy. + </summary> + </member> + <member name="P:Moq.Mock.IsDelegateMock"> + <summary> + Allows to check whether expression conversion to the <see cref="P:Moq.Mock.DelegateInterfaceMethod"/> + must be performed on the mock, without causing unnecessarily early initialization of + the mock instance, which breaks As{T}. + </summary> + </member> + <member name="P:Moq.Mock.DefaultValueProvider"> + <summary> + Specifies the class that will determine the default + value to return when invocations are made that + have no setups and need to return a default + value (for loose mocks). + </summary> + </member> + <member name="P:Moq.Mock.ImplementedInterfaces"> + <summary> + Exposes the list of extra interfaces implemented by the mock. + </summary> + </member> + <member name="T:Moq.MockRepository"> + <summary> + Utility repository class to use to construct multiple + mocks when consistent verification is + desired for all of them. + </summary> + <remarks> + If multiple mocks will be created during a test, passing + the desired <see cref="T:Moq.MockBehavior"/> (if different than the + <see cref="F:Moq.MockBehavior.Default"/> or the one + passed to the repository constructor) and later verifying each + mock can become repetitive and tedious. + <para> + This repository class helps in that scenario by providing a + simplified creation of multiple mocks with a default + <see cref="T:Moq.MockBehavior"/> (unless overriden by calling + <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/>) and posterior verification. + </para> + </remarks> + <example group="repository"> + The following is a straightforward example on how to + create and automatically verify strict mocks using a <see cref="T:Moq.MockRepository"/>: + <code> + var repository = new MockRepository(MockBehavior.Strict); + + var foo = repository.Create<IFoo>(); + var bar = repository.Create<IBar>(); + + // no need to call Verifiable() on the setup + // as we'll be validating all of them anyway. + foo.Setup(f => f.Do()); + bar.Setup(b => b.Redo()); + + // exercise the mocks here + + repository.VerifyAll(); + // At this point all setups are already checked + // and an optional MockException might be thrown. + // Note also that because the mocks are strict, any invocation + // that doesn't have a matching setup will also throw a MockException. + </code> + The following examples shows how to setup the repository + to create loose mocks and later verify only verifiable setups: + <code> + var repository = new MockRepository(MockBehavior.Loose); + + var foo = repository.Create<IFoo>(); + var bar = repository.Create<IBar>(); + + // this setup will be verified when we verify the repository + foo.Setup(f => f.Do()).Verifiable(); + + // this setup will NOT be verified + foo.Setup(f => f.Calculate()); + + // this setup will be verified when we verify the repository + bar.Setup(b => b.Redo()).Verifiable(); + + // exercise the mocks here + // note that because the mocks are Loose, members + // called in the interfaces for which no matching + // setups exist will NOT throw exceptions, + // and will rather return default values. + + repository.Verify(); + // At this point verifiable setups are already checked + // and an optional MockException might be thrown. + </code> + The following examples shows how to setup the repository with a + default strict behavior, overriding that default for a + specific mock: + <code> + var repository = new MockRepository(MockBehavior.Strict); + + // this particular one we want loose + var foo = repository.Create<IFoo>(MockBehavior.Loose); + var bar = repository.Create<IBar>(); + + // specify setups + + // exercise the mocks here + + repository.Verify(); + </code> + </example> + <seealso cref="T:Moq.MockBehavior"/> + </member> + <member name="T:Moq.MockFactory"> + <summary> + Utility factory class to use to construct multiple + mocks when consistent verification is + desired for all of them. + </summary> + <remarks> + If multiple mocks will be created during a test, passing + the desired <see cref="T:Moq.MockBehavior"/> (if different than the + <see cref="F:Moq.MockBehavior.Default"/> or the one + passed to the factory constructor) and later verifying each + mock can become repetitive and tedious. + <para> + This factory class helps in that scenario by providing a + simplified creation of multiple mocks with a default + <see cref="T:Moq.MockBehavior"/> (unless overriden by calling + <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/>) and posterior verification. + </para> + </remarks> + <example group="factory"> + The following is a straightforward example on how to + create and automatically verify strict mocks using a <see cref="T:Moq.MockFactory"/>: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(); + var bar = factory.Create<IBar>(); + + // no need to call Verifiable() on the setup + // as we'll be validating all of them anyway. + foo.Setup(f => f.Do()); + bar.Setup(b => b.Redo()); + + // exercise the mocks here + + factory.VerifyAll(); + // At this point all setups are already checked + // and an optional MockException might be thrown. + // Note also that because the mocks are strict, any invocation + // that doesn't have a matching setup will also throw a MockException. + </code> + The following examples shows how to setup the factory + to create loose mocks and later verify only verifiable setups: + <code> + var factory = new MockFactory(MockBehavior.Loose); + + var foo = factory.Create<IFoo>(); + var bar = factory.Create<IBar>(); + + // this setup will be verified when we verify the factory + foo.Setup(f => f.Do()).Verifiable(); + + // this setup will NOT be verified + foo.Setup(f => f.Calculate()); + + // this setup will be verified when we verify the factory + bar.Setup(b => b.Redo()).Verifiable(); + + // exercise the mocks here + // note that because the mocks are Loose, members + // called in the interfaces for which no matching + // setups exist will NOT throw exceptions, + // and will rather return default values. + + factory.Verify(); + // At this point verifiable setups are already checked + // and an optional MockException might be thrown. + </code> + The following examples shows how to setup the factory with a + default strict behavior, overriding that default for a + specific mock: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + // this particular one we want loose + var foo = factory.Create<IFoo>(MockBehavior.Loose); + var bar = factory.Create<IBar>(); + + // specify setups + + // exercise the mocks here + + factory.Verify(); + </code> + </example> + <seealso cref="T:Moq.MockBehavior"/> + </member> + <member name="M:Moq.MockFactory.#ctor(Moq.MockBehavior)"> + <summary> + Initializes the factory with the given <paramref name="defaultBehavior"/> + for newly created mocks from the factory. + </summary> + <param name="defaultBehavior">The behavior to use for mocks created + using the <see cref="M:Moq.MockFactory.Create``1"/> factory method if not overriden + by using the <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/> overload.</param> + </member> + <member name="M:Moq.MockFactory.Create``1"> + <summary> + Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> + specified at factory construction time. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example ignore="true"> + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(); + // use mock on tests + + factory.VerifyAll(); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(System.Object[])"> + <summary> + Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> + specified at factory construction time and with the + the given constructor arguments for the class. + </summary> + <remarks> + The mock will try to find the best match constructor given the + constructor arguments, and invoke that to initialize the instance. + This applies only to classes, not interfaces. + </remarks> + <typeparam name="T">Type to mock.</typeparam> + <param name="args">Constructor arguments for mocked classes.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example ignore="true"> + <code> + var factory = new MockFactory(MockBehavior.Default); + + var mock = factory.Create<MyBase>("Foo", 25, true); + // use mock on tests + + factory.Verify(); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"> + <summary> + Creates a new mock with the given <paramref name="behavior"/>. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">Behavior to use for the mock, which overrides + the default behavior specified at factory construction time.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example group="factory"> + The following example shows how to create a mock with a different + behavior to that specified as the default for the factory: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(MockBehavior.Loose); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior,System.Object[])"> + <summary> + Creates a new mock with the given <paramref name="behavior"/> + and with the the given constructor arguments for the class. + </summary> + <remarks> + The mock will try to find the best match constructor given the + constructor arguments, and invoke that to initialize the instance. + This applies only to classes, not interfaces. + </remarks> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">Behavior to use for the mock, which overrides + the default behavior specified at factory construction time.</param> + <param name="args">Constructor arguments for mocked classes.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example group="factory"> + The following example shows how to create a mock with a different + behavior to that specified as the default for the factory, passing + constructor arguments: + <code> + var factory = new MockFactory(MockBehavior.Default); + + var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.CreateMock``1(Moq.MockBehavior,System.Object[])"> + <summary> + Implements creation of a new mock within the factory. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">The behavior for the new mock.</param> + <param name="args">Optional arguments for the construction of the mock.</param> + </member> + <member name="M:Moq.MockFactory.Verify"> + <summary> + Verifies all verifiable expectations on all mocks created + by this factory. + </summary> + <seealso cref="M:Moq.Mock.Verify"/> + <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception> + </member> + <member name="M:Moq.MockFactory.VerifyAll"> + <summary> + Verifies all verifiable expectations on all mocks created + by this factory. + </summary> + <seealso cref="M:Moq.Mock.Verify"/> + <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception> + </member> + <member name="M:Moq.MockFactory.VerifyMocks(System.Action{Moq.Mock})"> + <summary> + Invokes <paramref name="verifyAction"/> for each mock + in <see cref="P:Moq.MockFactory.Mocks"/>, and accumulates the resulting + <see cref="T:Moq.MockVerificationException"/> that might be + thrown from the action. + </summary> + <param name="verifyAction">The action to execute against + each mock.</param> + </member> + <member name="P:Moq.MockFactory.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.MockFactory.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="P:Moq.MockFactory.Mocks"> + <summary> + Gets the mocks that have been created by this factory and + that will get verified together. + </summary> + </member> + <member name="M:Moq.MockRepository.Of``1"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.MockRepository.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.MockRepository.OneOf``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.MockRepository.OneOf``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.MockRepository.CreateMockQuery``1"> + <summary> + Creates the mock query with the underlying queriable implementation. + </summary> + </member> + <member name="M:Moq.MockRepository.CreateQueryable``1"> + <summary> + Wraps the enumerator inside a queryable. + </summary> + </member> + <member name="M:Moq.MockRepository.CreateMocks``1"> + <summary> + Method that is turned into the actual call from .Query{T}, to + transform the queryable query into a normal enumerable query. + This method is never used directly by consumers. + </summary> + </member> + <member name="M:Moq.MockRepository.#ctor(Moq.MockBehavior)"> + <summary> + Initializes the repository with the given <paramref name="defaultBehavior"/> + for newly created mocks from the repository. + </summary> + <param name="defaultBehavior">The behavior to use for mocks created + using the <see cref="M:Moq.MockFactory.Create``1"/> repository method if not overriden + by using the <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/> overload.</param> + </member> + <member name="T:Moq.EmptyDefaultValueProvider"> + <summary> + A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value + for invocations that do not have setups or return values, with loose mocks. + This is the default behavior for a mock. + </summary> + </member> + <member name="T:Moq.IDefaultValueProvider"> + <summary> + Interface to be implemented by classes that determine the + default value of non-expected invocations. + </summary> + </member> + <member name="M:Moq.IDefaultValueProvider.DefineDefault``1(``0)"> + <summary> + Defines the default value to return in all the methods returning <typeparamref name="T"/>. + </summary><typeparam name="T">The type of the return value.</typeparam><param name="value">The value to set as default.</param> + </member> + <member name="M:Moq.IDefaultValueProvider.ProvideDefault(System.Reflection.MethodInfo)"> + <summary> + Provides a value for the given member and arguments. + </summary><param name="member"> + The member to provide a default value for. + </param> + </member> + <member name="T:Moq.ExpressionStringBuilder"> + <summary> + The intention of <see cref="T:Moq.ExpressionStringBuilder"/> is to create a more readable + string representation for the failure message. + </summary> + </member> + <member name="T:Moq.Language.Flow.ICallbackResult"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IThrows"> + <summary> + Defines the <c>Throws</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IThrows.Throws(System.Exception)"> + <summary> + Specifies the exception to throw when the method is invoked. + </summary> + <param name="exception">Exception instance to throw.</param> + <example> + This example shows how to throw an exception when the method is + invoked with an empty string argument: + <code> + mock.Setup(x => x.Execute("")) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.Language.IThrows.Throws``1"> + <summary> + Specifies the type of exception to throw when the method is invoked. + </summary> + <typeparam name="TException">Type of exception to instantiate and throw when the setup is matched.</typeparam> + <example> + This example shows how to throw an exception when the method is + invoked with an empty string argument: + <code> + mock.Setup(x => x.Execute("")) + .Throws<ArgumentException>(); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IThrowsResult"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IOccurrence"> + <summary> + Defines occurrence members to constraint setups. + </summary> + </member> + <member name="M:Moq.Language.IOccurrence.AtMostOnce"> + <summary> + The expected invocation can happen at most once. + </summary> + <example> + <code> + var mock = new Mock<ICommand>(); + mock.Setup(foo => foo.Execute("ping")) + .AtMostOnce(); + </code> + </example> + </member> + <member name="M:Moq.Language.IOccurrence.AtMost(System.Int32)"> + <summary> + The expected invocation can happen at most specified number of times. + </summary> + <param name="callCount">The number of times to accept calls.</param> + <example> + <code> + var mock = new Mock<ICommand>(); + mock.Setup(foo => foo.Execute("ping")) + .AtMost( 5 ); + </code> + </example> + </member> + <member name="T:Moq.Language.IVerifies"> + <summary> + Defines the <c>Verifiable</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IVerifies.Verifiable"> + <summary> + Marks the expectation as verifiable, meaning that a call + to <see cref="M:Moq.Mock.Verify"/> will check if this particular + expectation was met. + </summary> + <example> + The following example marks the expectation as verifiable: + <code> + mock.Expect(x => x.Execute("ping")) + .Returns(true) + .Verifiable(); + </code> + </example> + </member> + <member name="M:Moq.Language.IVerifies.Verifiable(System.String)"> + <summary> + Marks the expectation as verifiable, meaning that a call + to <see cref="M:Moq.Mock.Verify"/> will check if this particular + expectation was met, and specifies a message for failures. + </summary> + <example> + The following example marks the expectation as verifiable: + <code> + mock.Expect(x => x.Execute("ping")) + .Returns(true) + .Verifiable("Ping should be executed always!"); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.ISetup`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.MethodCallReturn"> + <devdoc> + We need this non-generics base class so that + we can use <see cref="P:Moq.MethodCallReturn.HasReturnValue"/> from + generic code. + </devdoc> + </member> + <member name="T:Moq.Language.Flow.ISetup`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.Flow.IReturnsThrows`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.Flow.ISetupGetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallbackGetter`2"> + <summary> + Defines the <c>Callback</c> verb for property getter setups. + </summary> + <seealso cref="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"/> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.ICallbackGetter`2.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the property is retrieved. + </summary> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the property value being set. + <code> + mock.SetupGet(x => x.Suspended) + .Callback(() => called = true) + .Returns(true); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IReturnsThrowsGetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IReturnsGetter`2"> + <summary> + Defines the <c>Returns</c> verb for property get setups. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.Returns(`1)"> + <summary> + Specifies the value to return. + </summary> + <param name="value">The value to return, or <see langword="null"/>.</param> + <example> + Return a <c>true</c> value from the property getter call: + <code> + mock.SetupGet(x => x.Suspended) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.Returns(System.Func{`1})"> + <summary> + Specifies a function that will calculate the value to return for the property. + </summary> + <param name="valueFunction">The function that will calculate the return value.</param> + <example> + Return a calculated value when the property is retrieved: + <code> + mock.SetupGet(x => x.Suspended) + .Returns(() => returnValues[0]); + </code> + The lambda expression to retrieve the return value is lazy-executed, + meaning that its value may change depending on the moment the property + is retrieved and the value the <c>returnValues</c> array has at + that moment. + </example> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.CallBase"> + <summary> + Calls the real property of the object and returns its return value. + </summary> + <returns>The value calculated by the real property of the object.</returns> + </member> + <member name="T:Moq.Language.Flow.IReturnsResult`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.MockExtensions"> + <summary> + Provides additional methods on mocks. + </summary> + <remarks> + Those methods are useful for Testeroids support. + </remarks> + </member> + <member name="M:Moq.MockExtensions.ResetCalls(Moq.Mock)"> + <summary> + Resets the calls previously made on the specified mock. + </summary> + <param name="mock">The mock whose calls need to be reset.</param> + </member> + <member name="T:Moq.MockSequence"> + <summary> + Helper class to setup a full trace between many mocks + </summary> + </member> + <member name="M:Moq.MockSequence.#ctor"> + <summary> + Initialize a trace setup + </summary> + </member> + <member name="P:Moq.MockSequence.Cyclic"> + <summary> + Allow sequence to be repeated + </summary> + </member> + <member name="T:Moq.MockSequenceHelper"> + <summary> + define nice api + </summary> + </member> + <member name="M:Moq.MockSequenceHelper.InSequence``1(Moq.Mock{``0},Moq.MockSequence)"> + <summary> + Perform an expectation in the trace. + </summary> + </member> + <member name="T:Moq.MatcherAttribute"> + <summary> + Marks a method as a matcher, which allows complete replacement + of the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary> + <remarks> + <b>This feature has been deprecated in favor of the new + and simpler <see cref="T:Moq.Match`1"/>. + </b> + <para> + The argument matching is used to determine whether a concrete + invocation in the mock matches a given setup. This + matching mechanism is fully extensible. + </para> + <para> + There are two parts of a matcher: the compiler matcher + and the runtime matcher. + <list type="bullet"> + <item> + <term>Compiler matcher</term> + <description>Used to satisfy the compiler requirements for the + argument. Needs to be a method optionally receiving any arguments + you might need for the matching, but with a return type that + matches that of the argument. + <para> + Let's say I want to match a lists of orders that contains + a particular one. I might create a compiler matcher like the following: + </para> + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return null; + } + } + </code> + Now we can invoke this static method instead of an argument in an + invocation: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + </code> + Note that the return value from the compiler matcher is irrelevant. + This method will never be called, and is just used to satisfy the + compiler and to signal Moq that this is not a method that we want + to be invoked at runtime. + </description> + </item> + <item> + <term>Runtime matcher</term> + <description> + The runtime matcher is the one that will actually perform evaluation + when the test is run, and is defined by convention to have the + same signature as the compiler matcher, but where the return + value is the first argument to the call, which contains the + object received by the actual invocation at runtime: + <code> + public static bool Contains(IEnumerable<Order> orders, Order order) + { + return orders.Contains(order); + } + </code> + At runtime, the mocked method will be invoked with a specific + list of orders. This value will be passed to this runtime + matcher as the first argument, while the second argument is the + one specified in the setup (<c>x.Save(Orders.Contains(order))</c>). + <para> + The boolean returned determines whether the given argument has been + matched. If all arguments to the expected method are matched, then + the setup matches and is evaluated. + </para> + </description> + </item> + </list> + </para> + Using this extensible infrastructure, you can easily replace the entire + <see cref="T:Moq.It"/> set of matchers with your own. You can also avoid the + typical (and annoying) lengthy expressions that result when you have + multiple arguments that use generics. + </remarks> + <example> + The following is the complete example explained above: + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return null; + } + + public static bool Contains(IEnumerable<Order> orders, Order order) + { + return orders.Contains(order); + } + } + </code> + And the concrete test using this matcher: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + + // use mock, invoke Save, and have the matcher filter. + </code> + </example> + </member> + <member name="T:Moq.Mock`1"> + <summary> + Provides a mock implementation of <typeparamref name="T"/>. + </summary><remarks> + Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. + <para> + The behavior of the mock with regards to the setups and the actual calls is determined + by the optional <see cref="T:Moq.MockBehavior"/> that can be passed to the <see cref="M:Moq.Mock`1.#ctor(Moq.MockBehavior)"/> + constructor. + </para> + </remarks><typeparam name="T">Type to mock, which can be an interface or a class.</typeparam><example group="overview" order="0"> + The following example shows establishing setups with specific values + for method invocations: + <code> + // Arrange + var order = new Order(TALISKER, 50); + var mock = new Mock<IWarehouse>(); + + mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); + + // Act + order.Fill(mock.Object); + + // Assert + Assert.True(order.IsFilled); + </code> + The following example shows how to use the <see cref="T:Moq.It"/> class + to specify conditions for arguments instead of specific values: + <code> + // Arrange + var order = new Order(TALISKER, 50); + var mock = new Mock<IWarehouse>(); + + // shows how to expect a value within a range + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsInRange(0, 100, Range.Inclusive))) + .Returns(false); + + // shows how to throw for unexpected calls. + mock.Setup(x => x.Remove( + It.IsAny<string>(), + It.IsAny<int>())) + .Throws(new InvalidOperationException()); + + // Act + order.Fill(mock.Object); + + // Assert + Assert.False(order.IsFilled); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Expect(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.Expect``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.#ctor(System.Boolean)"> + <summary> + Ctor invoked by AsTInterface exclusively. + </summary> + </member> + <member name="M:Moq.Mock`1.#ctor"> + <summary> + Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see>. + </summary><example> + <code>var mock = new Mock<IFormatProvider>();</code> + </example> + </member> + <member name="M:Moq.Mock`1.#ctor(System.Object[])"> + <summary> + Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see> and with + the given constructor arguments for the class. (Only valid when <typeparamref name="T"/> is a class) + </summary><remarks> + The mock will try to find the best match constructor given the constructor arguments, and invoke that + to initialize the instance. This applies only for classes, not interfaces. + </remarks><example> + <code>var mock = new Mock<MyProvider>(someArgument, 25);</code> + </example><param name="args">Optional constructor arguments if the mocked type is a class.</param> + </member> + <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior)"> + <summary> + Initializes an instance of the mock with the specified <see cref="T:Moq.MockBehavior">behavior</see>. + </summary><example> + <code>var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed);</code> + </example><param name="behavior">Behavior of the mock.</param> + </member> + <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior,System.Object[])"> + <summary> + Initializes an instance of the mock with a specific <see cref="T:Moq.MockBehavior">behavior</see> with + the given constructor arguments for the class. + </summary><remarks> + The mock will try to find the best match constructor given the constructor arguments, and invoke that + to initialize the instance. This applies only to classes, not interfaces. + </remarks><example> + <code>var mock = new Mock<MyProvider>(someArgument, 25);</code> + </example><param name="behavior">Behavior of the mock.</param><param name="args">Optional constructor arguments if the mocked type is a class.</param> + </member> + <member name="M:Moq.Mock`1.OnGetObject"> + <summary> + Returns the mocked object value. + </summary> + </member> + <member name="M:Moq.Mock`1.Setup(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a void method. + </summary><remarks> + If more than one setup is specified for the same method or property, + the latest one wins and is the one that will be executed. + </remarks><param name="expression">Lambda expression that specifies the expected method invocation.</param><example group="setups"> + <code> + var mock = new Mock<IProcessor>(); + mock.Setup(x => x.Execute("ping")); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Setup``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a value returning method. + </summary><typeparam name="TResult">Type of the return value. Typically omitted as it can be inferred from the expression.</typeparam><remarks> + If more than one setup is specified for the same method or property, + the latest one wins and is the one that will be executed. + </remarks><param name="expression">Lambda expression that specifies the method invocation.</param><example group="setups"> + <code> + mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property getter. + </summary><remarks> + If more than one setup is set for the same property getter, + the latest one wins and is the one that will be executed. + </remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="expression">Lambda expression that specifies the property getter.</param><example group="setups"> + <code> + mock.SetupGet(x => x.Suspended) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupSet``1(System.Action{`0})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter. + </summary><remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + <para> + This overloads allows the use of a callback already + typed for the property type. + </para> + </remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="setterExpression">The Lambda expression that sets a property to a value.</param><example group="setups"> + <code> + mock.SetupSet(x => x.Suspended = true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupSet(System.Action{`0})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter. + </summary><remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + </remarks><param name="setterExpression">Lambda expression that sets a property to a value.</param><example group="setups"> + <code> + mock.SetupSet(x => x.Suspended = true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies that the given property should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. (this is also + known as "stubbing"). + </summary><typeparam name="TProperty"> + Type of the property, inferred from the property + expression (does not need to be specified). + </typeparam><param name="property">Property expression to stub.</param><example> + If you have an interface with an int property <c>Value</c>, you might + stub it using the following straightforward call: + <code> + var mock = new Mock<IHaveValue>(); + mock.Stub(v => v.Value); + </code> + After the <c>Stub</c> call has been issued, setting and + retrieving the object value will behave as expected: + <code> + IHaveValue v = mock.Object; + + v.Value = 5; + Assert.Equal(5, v.Value); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)"> + <summary> + Specifies that the given property should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. This overload + allows setting the initial value for the property. (this is also + known as "stubbing"). + </summary><typeparam name="TProperty"> + Type of the property, inferred from the property + expression (does not need to be specified). + </typeparam><param name="property">Property expression to stub.</param><param name="initialValue">Initial value for the property.</param><example> + If you have an interface with an int property <c>Value</c>, you might + stub it using the following straightforward call: + <code> + var mock = new Mock<IHaveValue>(); + mock.SetupProperty(v => v.Value, 5); + </code> + After the <c>SetupProperty</c> call has been issued, setting and + retrieving the object value will behave as expected: + <code> + IHaveValue v = mock.Object; + // Initial value was stored + Assert.Equal(5, v.Value); + + // New value set which changes the initial value + v.Value = 6; + Assert.Equal(6, v.Value); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupAllProperties"> + <summary> + Specifies that the all properties on the mock should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. (this is also + known as "stubbing"). The default value for each property will be the + one generated as specified by the <see cref="P:Moq.Mock.DefaultValue"/> property for the mock. + </summary><remarks> + If the mock <see cref="P:Moq.Mock.DefaultValue"/> is set to <see cref="F:Moq.DefaultValue.Mock"/>, + the mocked default values will also get all properties setup recursively. + </remarks> + </member> + <member name="M:Moq.Mock`1.When(System.Func{System.Boolean})"> + <!-- No matching elements were found for the following include tag --><include file="Mock.Generic.xdoc" path="docs/doc[@for="Mock{T}.When"]/*"/> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IProcessor>(); + // exercise mock + //... + // Will throw if the test code didn't call Execute with a "ping" string argument. + mock.Verify(proc => proc.Execute("ping")); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.Func{Moq.Times})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IProcessor>(); + // exercise mock + //... + // Will throw if the test code didn't call Execute with a "ping" string argument. + mock.Verify(proc => proc.Execute("ping")); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times,System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't call HasInventory. + mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock. Use in conjuntion + with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times})"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock. Use in conjuntion + with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock, specifying a failure + error message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't call HasInventory. + mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Verifies that a property was read on the mock. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was retrieved from it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't retrieve the IsClosed property. + mock.VerifyGet(warehouse => warehouse.IsClosed); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)"> + <summary> + Verifies that a property was read on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times})"> + <summary> + Verifies that a property was read on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was retrieved from it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't retrieve the IsClosed property. + mock.VerifyGet(warehouse => warehouse.IsClosed); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0})"> + <summary> + Verifies that a property was set on the mock. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was set on it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed = true); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times)"> + <summary> + Verifies that a property was set on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.Func{Moq.Times})"> + <summary> + Verifies that a property was set on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was set on it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times,System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.EventArgs)"> + <summary> + Raises the event referenced in <paramref name="eventExpression"/> using + the given <paramref name="args"/> argument. + </summary><exception cref="T:System.ArgumentException"> + The <paramref name="args"/> argument is + invalid for the target event invocation, or the <paramref name="eventExpression"/> is + not an event attach or detach expression. + </exception><example> + The following example shows how to raise a <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event: + <code> + var mock = new Mock<IViewModel>(); + + mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); + </code> + </example><example> + This example shows how to invoke an event with a custom event arguments + class in a view that will cause its corresponding presenter to + react by changing its state: + <code> + var mockView = new Mock<IOrdersView>(); + var presenter = new OrdersPresenter(mockView.Object); + + // Check that the presenter has no selection by default + Assert.Null(presenter.SelectedOrder); + + // Raise the event with a specific arguments data + mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); + + // Now the presenter reacted to the event, and we have a selected order + Assert.NotNull(presenter.SelectedOrder); + Assert.Equal("moq", presenter.SelectedOrder.ProductName); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.Object[])"> + <summary> + Raises the event referenced in <paramref name="eventExpression"/> using + the given <paramref name="args"/> argument for a non-EventHandler typed event. + </summary><exception cref="T:System.ArgumentException"> + The <paramref name="args"/> arguments are + invalid for the target event invocation, or the <paramref name="eventExpression"/> is + not an event attach or detach expression. + </exception><example> + The following example shows how to raise a custom event that does not adhere to + the standard <c>EventHandler</c>: + <code> + var mock = new Mock<IViewModel>(); + + mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); + </code> + </example> + </member> + <member name="P:Moq.Mock`1.Object"> + <summary> + Exposes the mocked object instance. + </summary> + </member> + <member name="P:Moq.Mock`1.DelegateInterfaceMethod"> + <inheritdoc /> + </member> + <member name="T:Moq.MockLegacyExtensions"> + <summary> + Provides legacy API members as extensions so that + existing code continues to compile, but new code + doesn't see then. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1,System.String)"> + <summary> + Obsolete. + </summary> + </member> + <member name="T:Moq.ObsoleteMockExtensions"> + <summary> + Provides additional methods on mocks. + </summary> + <devdoc> + Provided as extension methods as they confuse the compiler + with the overloads taking Action. + </devdoc> + </member> + <member name="M:Moq.ObsoleteMockExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter, regardless of its value. + </summary> + <remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + </remarks> + <typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam> + <typeparam name="T">Type of the mock.</typeparam> + <param name="mock">The target mock for the setup.</param> + <param name="expression">Lambda expression that specifies the property setter.</param> + <example group="setups"> + <code> + mock.SetupSet(x => x.Suspended); + </code> + </example> + <devdoc> + This method is not legacy, but must be on an extension method to avoid + confusing the compiler with the new Action syntax. + </devdoc> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Verifies that a property has been set on the mock, regarless of its value. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <param name="expression">Expression to verify.</param> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)"> + <summary> + Verifies that a property has been set on the mock, specifying a failure + error message. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <param name="expression">Expression to verify.</param> + <param name="failMessage">Message to show if verification fails.</param> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times)"> + <summary> + Verifies that a property has been set on the mock, regardless + of the value but only the specified number of times. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="expression">Expression to verify.</param> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times,System.String)"> + <summary> + Verifies that a property has been set on the mock, regardless + of the value but only the specified number of times, and specifying a failure + error message. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="failMessage">Message to show if verification fails.</param> + <param name="expression">Expression to verify.</param> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="T:Moq.SequenceExtensions"> + <summary> + Helper for sequencing return values in the same method. + </summary> + </member> + <member name="M:Moq.SequenceExtensions.SetupSequence``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Return a sequence of values, once per call. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToLambda(System.Linq.Expressions.Expression)"> + <summary> + Casts the expression to a lambda expression, removing + a cast if there's any. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToMethodCall(System.Linq.Expressions.LambdaExpression)"> + <summary> + Casts the body of the lambda expression to a <see cref="T:System.Linq.Expressions.MethodCallExpression"/>. + </summary> + <exception cref="T:System.ArgumentException">If the body is not a method call.</exception> + </member> + <member name="M:Moq.ExpressionExtensions.ToPropertyInfo(System.Linq.Expressions.LambdaExpression)"> + <summary> + Converts the body of the lambda expression into the <see cref="T:System.Reflection.PropertyInfo"/> referenced by it. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.LambdaExpression)"> + <summary> + Checks whether the body of the lambda expression is a property access. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.Expression)"> + <summary> + Checks whether the expression is a property access. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.LambdaExpression)"> + <summary> + Checks whether the body of the lambda expression is a property indexer, which is true + when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose + <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> + equal to <see langword="true"/>. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.Expression)"> + <summary> + Checks whether the expression is a property indexer, which is true + when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose + <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> + equal to <see langword="true"/>. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.CastTo``1(System.Linq.Expressions.Expression)"> + <summary> + Creates an expression that casts the given expression to the <typeparamref name="T"/> + type. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToStringFixed(System.Linq.Expressions.Expression)"> + <devdoc> + TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 + is fixed. + </devdoc> + </member> + <member name="M:Moq.ExpressionExtensions.GetCallInfo(System.Linq.Expressions.LambdaExpression,Moq.Mock)"> + <summary> + Extracts, into a common form, information from a <see cref="T:System.Linq.Expressions.LambdaExpression"/> + around either a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> (for a normal method call) + or a <see cref="T:System.Linq.Expressions.InvocationExpression"/> (for a delegate invocation). + </summary> + </member> + <member name="M:Moq.Extensions.IsDelegate(System.Type)"> + <summary> + Tests if a type is a delegate type (subclasses <see cref="T:System.Delegate"/>). + </summary> + </member> + <member name="T:Moq.Evaluator"> + <summary> + Provides partial evaluation of subtrees, whenever they can be evaluated locally. + </summary> + <author>Matt Warren: http://blogs.msdn.com/mattwar</author> + <contributor>Documented by InSTEDD: http://www.instedd.org</contributor> + </member> + <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression,System.Func{System.Linq.Expressions.Expression,System.Boolean})"> + <summary> + Performs evaluation and replacement of independent sub-trees + </summary> + <param name="expression">The root of the expression tree.</param> + <param name="fnCanBeEvaluated">A function that decides whether a given expression + node can be part of the local function.</param> + <returns>A new tree with sub-trees evaluated and replaced.</returns> + </member> + <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression)"> + <summary> + Performs evaluation and replacement of independent sub-trees + </summary> + <param name="expression">The root of the expression tree.</param> + <returns>A new tree with sub-trees evaluated and replaced.</returns> + </member> + <member name="T:Moq.Evaluator.SubtreeEvaluator"> + <summary> + Evaluates and replaces sub-trees when first candidate is reached (top-down) + </summary> + </member> + <member name="T:Moq.Evaluator.Nominator"> + <summary> + Performs bottom-up analysis to determine which nodes can possibly + be part of an evaluated sub-tree. + </summary> + </member> + <member name="M:Moq.Guard.NotNull``1(System.Linq.Expressions.Expression{System.Func{``0}},``0)"> + <summary> + Ensures the given <paramref name="value"/> is not null. + Throws <see cref="T:System.ArgumentNullException"/> otherwise. + </summary> + </member> + <member name="M:Moq.Guard.NotNullOrEmpty(System.Linq.Expressions.Expression{System.Func{System.String}},System.String)"> + <summary> + Ensures the given string <paramref name="value"/> is not null or empty. + Throws <see cref="T:System.ArgumentNullException"/> in the first case, or + <see cref="T:System.ArgumentException"/> in the latter. + </summary> + </member> + <member name="M:Moq.Guard.NotOutOfRangeInclusive``1(System.Linq.Expressions.Expression{System.Func{``0}},``0,``0,``0)"> + <summary> + Checks an argument to ensure it is in the specified range including the edges. + </summary> + <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type. + </typeparam> + <param name="reference">The expression containing the name of the argument.</param> + <param name="value">The argument value to check.</param> + <param name="from">The minimun allowed value for the argument.</param> + <param name="to">The maximun allowed value for the argument.</param> + </member> + <member name="M:Moq.Guard.NotOutOfRangeExclusive``1(System.Linq.Expressions.Expression{System.Func{``0}},``0,``0,``0)"> + <summary> + Checks an argument to ensure it is in the specified range excluding the edges. + </summary> + <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type. + </typeparam> + <param name="reference">The expression containing the name of the argument.</param> + <param name="value">The argument value to check.</param> + <param name="from">The minimun allowed value for the argument.</param> + <param name="to">The maximun allowed value for the argument.</param> + </member> + <member name="T:Moq.IMocked`1"> + <summary> + Implemented by all generated mock object instances. + </summary> + </member> + <member name="T:Moq.IMocked"> + <summary> + Implemented by all generated mock object instances. + </summary> + </member> + <member name="P:Moq.IMocked.Mock"> + <summary> + Reference the Mock that contains this as the <c>mock.Object</c> value. + </summary> + </member> + <member name="P:Moq.IMocked`1.Mock"> + <summary> + Reference the Mock that contains this as the <c>mock.Object</c> value. + </summary> + </member> + <member name="T:Moq.Interceptor"> + <summary> + Implements the actual interception and method invocation for + all mocks. + </summary> + </member> + <member name="T:Moq.Language.Flow.ISetupSetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallbackSetter`1"> + <summary> + Defines the <c>Callback</c> verb for property setter setups. + </summary> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.ICallbackSetter`1.Callback(System.Action{`0})"> + <summary> + Specifies a callback to invoke when the property is set that receives the + property value being set. + </summary> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the property value being set. + <code> + mock.SetupSet(x => x.Suspended) + .Callback((bool state) => Console.WriteLine(state)); + </code> + </example> + </member> + <member name="T:Moq.It"> + <summary> + Allows the specification of a matching condition for an + argument in a method invocation, rather than a specific + argument value. "It" refers to the argument being matched. + </summary><remarks> + This class allows the setup to match a method invocation + with an arbitrary value, with a value in a specified range, or + even one that matches a given predicate. + </remarks> + </member> + <member name="M:Moq.It.IsAny``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type. + </summary><remarks> + Typically used when the actual argument value for a method + call is not relevant. + </remarks><example> + <code> + // Throws an exception for a call to Remove with any string value. + mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); + </code> + </example><typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.It.IsNotNull``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type, except null. + </summary><typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.It.Is``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Matches any value that satisfies the given predicate. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="match">The predicate used to match the method argument.</param><remarks> + Allows the specification of a predicate to perform matching + of method call arguments. + </remarks><example> + This example shows how to return the value <c>1</c> whenever the argument to the + <c>Do</c> method is an even number. + <code> + mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) + .Returns(1); + </code> + This example shows how to throw an exception if the argument to the + method is a negative number: + <code> + mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)"> + <summary> + Matches any value that is in the range specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="from">The lower bound of the range.</param><param name="to">The upper bound of the range.</param><param name="rangeKind"> + The kind of range. See <see cref="T:Moq.Range"/>. + </param><example> + The following example shows how to expect a method call + with an integer argument within the 0..100 range. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsInRange(0, 100, Range.Inclusive))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsIn``1(System.Collections.Generic.IEnumerable{``0})"> + <summary> + Matches any value that is present in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of possible values.</param><example> + The following example shows how to expect a method call + with an integer argument with value from a list. + <code> + var values = new List<int> { 1, 2, 3 }; + + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsIn(values))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsIn``1(``0[])"> + <summary> + Matches any value that is present in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of possible values.</param><example> + The following example shows how to expect a method call + with an integer argument with a value of 1, 2, or 3. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsIn(1, 2, 3))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsNotIn``1(System.Collections.Generic.IEnumerable{``0})"> + <summary> + Matches any value that is not found in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of disallowed values.</param><example> + The following example shows how to expect a method call + with an integer argument with value not found from a list. + <code> + var values = new List<int> { 1, 2, 3 }; + + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsNotIn(values))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsNotIn``1(``0[])"> + <summary> + Matches any value that is not found in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of disallowed values.</param><example> + The following example shows how to expect a method call + with an integer argument of any value except 1, 2, or 3. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsNotIn(1, 2, 3))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsRegex(System.String)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary><param name="regex">The pattern to use to match the string argument value.</param><example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression: + <code> + mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); + </code> + </example> + </member> + <member name="M:Moq.It.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary><param name="regex">The pattern to use to match the string argument value.</param><param name="options">The options used to interpret the pattern.</param><example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression, in a case insensitive way: + <code> + mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); + </code> + </example> + </member> + <member name="T:Moq.Matchers.MatcherAttributeMatcher"> + <summary> + Matcher to treat static functions as matchers. + + mock.Setup(x => x.StringMethod(A.MagicString())); + + public static class A + { + [Matcher] + public static string MagicString() { return null; } + public static bool MagicString(string arg) + { + return arg == "magic"; + } + } + + Will succeed if: mock.Object.StringMethod("magic"); + and fail with any other call. + </summary> + </member> + <member name="T:Moq.MockBehavior"> + <summary> + Options to customize the behavior of the mock. + </summary> + </member> + <member name="F:Moq.MockBehavior.Strict"> + <summary> + Causes the mock to always throw + an exception for invocations that don't have a + corresponding setup. + </summary> + </member> + <member name="F:Moq.MockBehavior.Loose"> + <summary> + Will never throw exceptions, returning default + values when necessary (null for reference types, + zero for value types or empty enumerables and arrays). + </summary> + </member> + <member name="F:Moq.MockBehavior.Default"> + <summary> + Default mock behavior, which equals <see cref="F:Moq.MockBehavior.Loose"/>. + </summary> + </member> + <member name="T:Moq.MockException"> + <summary> + Exception thrown by mocks when setups are not matched, + the mock is not properly setup, etc. + </summary> + <remarks> + A distinct exception type is provided so that exceptions + thrown by the mock can be differentiated in tests that + expect other exceptions to be thrown (i.e. ArgumentException). + <para> + Richer exception hierarchy/types are not provided as + tests typically should <b>not</b> catch or expect exceptions + from the mocks. These are typically the result of changes + in the tested class or its collaborators implementation, and + result in fixes in the mock setup so that they dissapear and + allow the test to pass. + </para> + </remarks> + </member> + <member name="M:Moq.MockException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Supports the serialization infrastructure. + </summary> + <param name="info">Serialization information.</param> + <param name="context">Streaming context.</param> + </member> + <member name="M:Moq.MockException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Supports the serialization infrastructure. + </summary> + <param name="info">Serialization information.</param> + <param name="context">Streaming context.</param> + </member> + <member name="P:Moq.MockException.IsVerificationError"> + <summary> + Indicates whether this exception is a verification fault raised by Verify() + </summary> + </member> + <member name="T:Moq.MockException.ExceptionReason"> + <summary> + Made internal as it's of no use for + consumers, but it's important for + our own tests. + </summary> + </member> + <member name="T:Moq.MockVerificationException"> + <devdoc> + Used by the mock factory to accumulate verification + failures. + </devdoc> + </member> + <member name="M:Moq.MockVerificationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Supports the serialization infrastructure. + </summary> + </member> + <member name="T:Moq.Properties.Resources"> + <summary> + A strongly-typed resource class, for looking up localized strings, etc. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ResourceManager"> + <summary> + Returns the cached ResourceManager instance used by this class. + </summary> + </member> + <member name="P:Moq.Properties.Resources.Culture"> + <summary> + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + </summary> + </member> + <member name="P:Moq.Properties.Resources.AlreadyInitialized"> + <summary> + Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ArgumentCannotBeEmpty"> + <summary> + Looks up a localized string similar to Value cannot be an empty string.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.AsMustBeInterface"> + <summary> + Looks up a localized string similar to Can only add interfaces to the mock.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.CantSetReturnValueForVoid"> + <summary> + Looks up a localized string similar to Can't set return value for void method {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorArgsForDelegate"> + <summary> + Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorArgsForInterface"> + <summary> + Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorNotFound"> + <summary> + Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.EventNofFound"> + <summary> + Looks up a localized string similar to Could not locate event for attach or detach method {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.FieldsNotSupported"> + <summary> + Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.InvalidMockClass"> + <summary> + Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . + </summary> + </member> + <member name="P:Moq.Properties.Resources.InvalidMockGetType"> + <summary> + Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. + Please cast the argument to one of the supported types: {1}. + Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqBinaryOperatorNotSupported"> + <summary> + Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqMethodNotSupported"> + <summary> + Looks up a localized string similar to LINQ method '{0}' not supported.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqMethodNotVirtual"> + <summary> + Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MemberMissing"> + <summary> + Looks up a localized string similar to Member {0}.{1} does not exist.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MethodIsPublic"> + <summary> + Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: + mock.Setup(x => x.{1}()); + . + </summary> + </member> + <member name="P:Moq.Properties.Resources.MockExceptionMessage"> + <summary> + Looks up a localized string similar to {0} invocation failed with mock behavior {1}. + {2}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MoreThanNCalls"> + <summary> + Looks up a localized string similar to Expected only {0} calls to {1}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MoreThanOneCall"> + <summary> + Looks up a localized string similar to Expected only one call to {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeast"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at least {2} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeastOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at least once, but was never performed: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMost"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at most {3} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMostOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at most once, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenExclusive"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenInclusive"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsExactly"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock exactly {2} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsNever"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock should never have been performed, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock once, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoSetup"> + <summary> + Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ObjectInstanceNotMock"> + <summary> + Looks up a localized string similar to Object instance was not created by Moq.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.OutExpressionMustBeConstantValue"> + <summary> + Looks up a localized string similar to Out expression must evaluate to a constant value.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyGetNotFound"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not have a getter.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyMissing"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not exist.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyNotReadable"> + <summary> + Looks up a localized string similar to Property {0}.{1} is write-only.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyNotWritable"> + <summary> + Looks up a localized string similar to Property {0}.{1} is read-only.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertySetNotFound"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not have a setter.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.RaisedUnassociatedEvent"> + <summary> + Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.RefExpressionMustBeConstantValue"> + <summary> + Looks up a localized string similar to Ref expression must evaluate to a constant value.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ReturnValueRequired"> + <summary> + Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupLambda"> + <summary> + Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNever"> + <summary> + Looks up a localized string similar to Invocation {0} should not have been made.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotMethod"> + <summary> + Looks up a localized string similar to Expression is not a method invocation: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotProperty"> + <summary> + Looks up a localized string similar to Expression is not a property access: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotSetter"> + <summary> + Looks up a localized string similar to Expression is not a property setter invocation.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupOnNonMemberMethod"> + <summary> + Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupOnNonOverridableMember"> + <summary> + Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.TypeNotImplementInterface"> + <summary> + Looks up a localized string similar to Type {0} does not implement required interface {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.TypeNotInheritFromType"> + <summary> + Looks up a localized string similar to Type {0} does not from required type {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnexpectedPublicProperty"> + <summary> + Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: + mock.Setup(x => x.{1}).Returns(value); + mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one + mock.SetupSet(x => x.{1}).Callback(callbackDelegate); + . + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedExpression"> + <summary> + Looks up a localized string similar to Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedIntermediateExpression"> + <summary> + Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedIntermediateType"> + <summary> + Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedMatcherParamsForSetter"> + <summary> + Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedMember"> + <summary> + Looks up a localized string similar to Member {0} is not supported for protected mocking.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedNonStaticMatcherForSetter"> + <summary> + Looks up a localized string similar to Setter expression can only use static custom matchers.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.VerficationFailed"> + <summary> + Looks up a localized string similar to The following setups were not matched: + {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.VerifyOnNonVirtualMember"> + <summary> + Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. + </summary> + </member> + <member name="T:Moq.Protected.IProtectedMock`1"> + <summary> + Allows setups to be specified for protected members by using their + name as a string, rather than strong-typing them which is not possible + due to their visibility. + </summary> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Setup(System.String,System.Object[])"> + <summary> + Specifies a setup for a void method invocation with the given + <paramref name="voidMethodName"/>, optionally specifying arguments for the method call. + </summary> + <param name="voidMethodName">The name of the void method to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Setup``1(System.String,System.Object[])"> + <summary> + Specifies a setup for an invocation on a property or a non void method with the given + <paramref name="methodOrPropertyName"/>, optionally specifying arguments for the method call. + </summary> + <param name="methodOrPropertyName">The name of the method or property to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <typeparam name="TResult">The return type of the method or property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.SetupGet``1(System.String)"> + <summary> + Specifies a setup for an invocation on a property getter with the given + <paramref name="propertyName"/>. + </summary> + <param name="propertyName">The name of the property.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.SetupSet``1(System.String,System.Object)"> + <summary> + Specifies a setup for an invocation on a property setter with the given + <paramref name="propertyName"/>. + </summary> + <param name="propertyName">The name of the property.</param> + <param name="value">The property value. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Verify(System.String,Moq.Times,System.Object[])"> + <summary> + Specifies a verify for a void method with the given <paramref name="methodName"/>, + optionally specifying arguments for the method call. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="methodName">The name of the void method to be verified.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Verify``1(System.String,Moq.Times,System.Object[])"> + <summary> + Specifies a verify for an invocation on a property or a non void method with the given + <paramref name="methodName"/>, optionally specifying arguments for the method call. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="methodName">The name of the method or property to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <typeparam name="TResult">The type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.VerifyGet``1(System.String,Moq.Times)"> + <summary> + Specifies a verify for an invocation on a property getter with the given + <paramref name="propertyName"/>. + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + </summary> + <param name="propertyName">The name of the property.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.VerifySet``1(System.String,Moq.Times,System.Object)"> + <summary> + Specifies a setup for an invocation on a property setter with the given + <paramref name="propertyName"/>. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="propertyName">The name of the property.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="value">The property value.</param> + <typeparam name="TProperty">The type of the property. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</typeparam> + </member> + <member name="T:Moq.Protected.ItExpr"> + <summary> + Allows the specification of a matching condition for an + argument in a protected member setup, rather than a specific + argument value. "ItExpr" refers to the argument being matched. + </summary> + <remarks> + <para>Use this variant of argument matching instead of + <see cref="T:Moq.It"/> for protected setups.</para> + This class allows the setup to match a method invocation + with an arbitrary value, with a value in a specified range, or + even one that matches a given predicate, or null. + </remarks> + </member> + <member name="M:Moq.Protected.ItExpr.IsNull``1"> + <summary> + Matches a null value of the given <typeparamref name="TValue"/> type. + </summary> + <remarks> + Required for protected mocks as the null value cannot be used + directly as it prevents proper method overload selection. + </remarks> + <example> + <code> + // Throws an exception for a call to Remove with a null string value. + mock.Protected() + .Setup("Remove", ItExpr.IsNull<string>()) + .Throws(new InvalidOperationException()); + </code> + </example> + <typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.Protected.ItExpr.IsAny``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type. + </summary> + <remarks> + Typically used when the actual argument value for a method + call is not relevant. + </remarks> + <example> + <code> + // Throws an exception for a call to Remove with any string value. + mock.Protected() + .Setup("Remove", ItExpr.IsAny<string>()) + .Throws(new InvalidOperationException()); + </code> + </example> + <typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.Protected.ItExpr.Is``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Matches any value that satisfies the given predicate. + </summary> + <typeparam name="TValue">Type of the argument to check.</typeparam> + <param name="match">The predicate used to match the method argument.</param> + <remarks> + Allows the specification of a predicate to perform matching + of method call arguments. + </remarks> + <example> + This example shows how to return the value <c>1</c> whenever the argument to the + <c>Do</c> method is an even number. + <code> + mock.Protected() + .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) + .Returns(1); + </code> + This example shows how to throw an exception if the argument to the + method is a negative number: + <code> + mock.Protected() + .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsInRange``1(``0,``0,Moq.Range)"> + <summary> + Matches any value that is in the range specified. + </summary> + <typeparam name="TValue">Type of the argument to check.</typeparam> + <param name="from">The lower bound of the range.</param> + <param name="to">The upper bound of the range.</param> + <param name="rangeKind">The kind of range. See <see cref="T:Moq.Range"/>.</param> + <example> + The following example shows how to expect a method call + with an integer argument within the 0..100 range. + <code> + mock.Protected() + .Setup("HasInventory", + ItExpr.IsAny<string>(), + ItExpr.IsInRange(0, 100, Range.Inclusive)) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsRegex(System.String)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary> + <param name="regex">The pattern to use to match the string argument value.</param> + <example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression: + <code> + mock.Protected() + .Setup("Check", ItExpr.IsRegex("[a-z]+")) + .Returns(1); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary> + <param name="regex">The pattern to use to match the string argument value.</param> + <param name="options">The options used to interpret the pattern.</param> + <example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression, in a case insensitive way: + <code> + mock.Protected() + .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) + .Returns(1); + </code> + </example> + </member> + <member name="T:Moq.Protected.ProtectedExtension"> + <summary> + Enables the <c>Protected()</c> method on <see cref="T:Moq.Mock`1"/>, + allowing setups to be set for protected members by using their + name as a string, rather than strong-typing them which is not possible + due to their visibility. + </summary> + </member> + <member name="M:Moq.Protected.ProtectedExtension.Protected``1(Moq.Mock{``0})"> + <summary> + Enable protected setups for the mock. + </summary> + <typeparam name="T">Mocked object type. Typically omitted as it can be inferred from the mock instance.</typeparam> + <param name="mock">The mock to set the protected setups on.</param> + </member> + <member name="T:ThisAssembly"> + <group name="overview" title="Overview" order="0" /> + <group name="setups" title="Specifying setups" order="1" /> + <group name="returns" title="Returning values from members" order="2" /> + <group name="verification" title="Verifying setups" order="3" /> + <group name="advanced" title="Advanced scenarios" order="99" /> + <group name="factory" title="Using MockFactory for consistency across mocks" order="4" /> + </member> + <member name="T:Moq.Range"> + <summary> + Kind of range to use in a filter specified through + <see cref="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)"/>. + </summary> + </member> + <member name="F:Moq.Range.Inclusive"> + <summary> + The range includes the <c>to</c> and + <c>from</c> values. + </summary> + </member> + <member name="F:Moq.Range.Exclusive"> + <summary> + The range does not include the <c>to</c> and + <c>from</c> values. + </summary> + </member> + <member name="T:Moq.DefaultValue"> + <summary> + Determines the way default values are generated + calculated for loose mocks. + </summary> + </member> + <member name="F:Moq.DefaultValue.Empty"> + <summary> + Default behavior, which generates empty values for + value types (i.e. default(int)), empty array and + enumerables, and nulls for all other reference types. + </summary> + </member> + <member name="F:Moq.DefaultValue.Mock"> + <summary> + Whenever the default value generated by <see cref="F:Moq.DefaultValue.Empty"/> + is null, replaces this value with a mock (if the type + can be mocked). + </summary> + <remarks> + For sealed classes, a null value will be generated. + </remarks> + </member> + <member name="T:Moq.Linq.MockQueryable`1"> + <summary> + A default implementation of IQueryable for use with QueryProvider + </summary> + </member> + <member name="M:Moq.Linq.MockQueryable`1.#ctor(System.Linq.Expressions.MethodCallExpression)"> + <summary> + The <paramref name="underlyingCreateMocks"/> is a + static method that returns an IQueryable of Mocks of T which is used to + apply the linq specification to. + </summary> + </member> + <member name="T:Moq.Match"> + <summary> + Allows creation custom value matchers that can be used on setups and verification, + completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary><remarks> + See also <see cref="T:Moq.Match`1"/>. + </remarks> + </member> + <member name="M:Moq.Match.Matcher``1"> + <devdoc> + Provided for the sole purpose of rendering the delegate passed to the + matcher constructor if no friendly render lambda is provided. + </devdoc> + </member> + <member name="M:Moq.Match.Create``1(System.Predicate{``0})"> + <summary> + Initializes the match with the condition that + will be checked in order to match invocation + values. + </summary><param name="condition">The condition to match against actual values.</param><remarks> + <seealso cref="T:Moq.Match`1"/> + </remarks> + </member> + <member name="M:Moq.Match.Create``1(System.Predicate{``0},System.Linq.Expressions.Expression{System.Func{``0}})"> + <!-- No matching elements were found for the following include tag --><include file="Match.xdoc" path="docs/doc[@for="Match.Create{T}(condition,renderExpression"]/*"/> + </member> + <member name="M:Moq.Match.SetLastMatch``1(Moq.Match{``0})"> + <devdoc> + This method is used to set an expression as the last matcher invoked, + which is used in the SetupSet to allow matchers in the prop = value + delegate expression. This delegate is executed in "fluent" mode in + order to capture the value being set, and construct the corresponding + methodcall. + This is also used in the MatcherFactory for each argument expression. + This method ensures that when we execute the delegate, we + also track the matcher that was invoked, so that when we create the + methodcall we build the expression using it, rather than the null/default + value returned from the actual invocation. + </devdoc> + </member> + <member name="T:Moq.Match`1"> + <summary> + Allows creation custom value matchers that can be used on setups and verification, + completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary><typeparam name="T">Type of the value to match.</typeparam><remarks> + The argument matching is used to determine whether a concrete + invocation in the mock matches a given setup. This + matching mechanism is fully extensible. + </remarks><example> + Creating a custom matcher is straightforward. You just need to create a method + that returns a value from a call to <see cref="M:Moq.Match.Create``1(System.Predicate{``0})"/> with + your matching condition and optional friendly render expression: + <code> + [Matcher] + public Order IsBigOrder() + { + return Match<Order>.Create( + o => o.GrandTotal >= 5000, + /* a friendly expression to render on failures */ + () => IsBigOrder()); + } + </code> + This method can be used in any mock setup invocation: + <code> + mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); + </code> + At runtime, Moq knows that the return value was a matcher (note that the method MUST be + annotated with the [Matcher] attribute in order to determine this) and + evaluates your predicate with the actual value passed into your predicate. + <para> + Another example might be a case where you want to match a lists of orders + that contains a particular one. You might create matcher like the following: + </para> + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); + } + } + </code> + Now we can invoke this static method instead of an argument in an + invocation: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + </code> + </example> + </member> + <member name="T:Moq.FluentMockContext"> + <summary> + Tracks the current mock and interception context. + </summary> + </member> + <member name="P:Moq.FluentMockContext.IsActive"> + <summary> + Having an active fluent mock context means that the invocation + is being performed in "trial" mode, just to gather the + target method and arguments that need to be matched later + when the actual invocation is made. + </summary> + </member> + <member name="T:Moq.MockDefaultValueProvider"> + <summary> + A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value + for non-mockeable types, and mocks for all other types (interfaces and + non-sealed classes) that can be mocked. + </summary> + </member> + <member name="T:Moq.Mocks"> + <summary> + Allows querying the universe of mocks for those that behave + according to the LINQ query specification. + </summary> + <devdoc> + This entry-point into Linq to Mocks is the only one in the root Moq + namespace to ease discovery. But to get all the mocking extension + methods on Object, a using of Moq.Linq must be done, so that the + polluting of the intellisense for all objects is an explicit opt-in. + </devdoc> + </member> + <member name="M:Moq.Mocks.Of``1"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.Mocks.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.Mocks.OneOf``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mocks.OneOf``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mocks.CreateMockQuery``1"> + <summary> + Creates the mock query with the underlying queriable implementation. + </summary> + </member> + <member name="M:Moq.Mocks.CreateQueryable``1"> + <summary> + Wraps the enumerator inside a queryable. + </summary> + </member> + <member name="M:Moq.Mocks.CreateMocks``1"> + <summary> + Method that is turned into the actual call from .Query{T}, to + transform the queryable query into a normal enumerable query. + This method is never used directly by consumers. + </summary> + </member> + <member name="M:Moq.Mocks.SetPropery``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Extension method used to support Linq-like setup properties that are not virtual but do have + a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) + </summary> + </member> + <member name="T:Moq.QueryableMockExtensions"> + <summary> + Helper extensions that are used by the query translator. + </summary> + </member> + <member name="M:Moq.QueryableMockExtensions.FluentMock``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Retrieves a fluent mock from the given setup expression. + </summary> + </member> + <member name="M:Moq.Proxy.IProxyFactory.GetDelegateProxyInterface(System.Type,System.Reflection.MethodInfo@)"> + <summary> + Gets an autogenerated interface with a method on it that matches the signature of the specified + <paramref name="delegateType"/>. + </summary> + <remarks> + Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. + This is how we support delegate mocking. The factory caches such interfaces and reuses them + for repeated requests for the same delegate type. + </remarks> + <param name="delegateType">The delegate type for which an interface is required.</param> + <param name="delegateInterfaceMethod">The method on the autogenerated interface.</param> + </member> + <member name="M:Moq.Proxy.CastleProxyFactory.CreateProxy(System.Type,Moq.Proxy.ICallInterceptor,System.Type[],System.Object[])"> + <inheritdoc /> + </member> + <member name="M:Moq.Proxy.CastleProxyFactory.GetDelegateProxyInterface(System.Type,System.Reflection.MethodInfo@)"> + <inheritdoc /> + </member> + <member name="T:Moq.Times"> + <summary> + Defines the number of invocations allowed by a mocked method. + </summary> + </member> + <member name="M:Moq.Times.AtLeast(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked <paramref name="callCount"/> times as minimum. + </summary><param name="callCount">The minimun number of times.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtLeastOnce"> + <summary> + Specifies that a mocked method should be invoked one time as minimum. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtMost(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked <paramref name="callCount"/> time as maximun. + </summary><param name="callCount">The maximun number of times.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtMostOnce"> + <summary> + Specifies that a mocked method should be invoked one time as maximun. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Between(System.Int32,System.Int32,Moq.Range)"> + <summary> + Specifies that a mocked method should be invoked between <paramref name="callCountFrom"/> and + <paramref name="callCountTo"/> times. + </summary><param name="callCountFrom">The minimun number of times.</param><param name="callCountTo">The maximun number of times.</param><param name="rangeKind"> + The kind of range. See <see cref="T:Moq.Range"/>. + </param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Exactly(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked exactly <paramref name="callCount"/> times. + </summary><param name="callCount">The times that a method or property can be called.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Never"> + <summary> + Specifies that a mocked method should not be invoked. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Once"> + <summary> + Specifies that a mocked method should be invoked exactly one time. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Equals(System.Object)"> + <summary> + Determines whether the specified <see cref="T:System.Object"/> is equal to this instance. + </summary><param name="obj"> + The <see cref="T:System.Object"/> to compare with this instance. + </param><returns> + <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>. + </returns> + </member> + <member name="M:Moq.Times.GetHashCode"> + <summary> + Returns a hash code for this instance. + </summary><returns> + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + </returns> + </member> + <member name="M:Moq.Times.op_Equality(Moq.Times,Moq.Times)"> + <summary> + Determines whether two specified <see cref="T:Moq.Times"/> objects have the same value. + </summary><param name="left"> + The first <see cref="T:Moq.Times"/>. + </param><param name="right"> + The second <see cref="T:Moq.Times"/>. + </param><returns> + <c>true</c> if the value of left is the same as the value of right; otherwise, <c>false</c>. + </returns> + </member> + <member name="M:Moq.Times.op_Inequality(Moq.Times,Moq.Times)"> + <summary> + Determines whether two specified <see cref="T:Moq.Times"/> objects have different values. + </summary><param name="left"> + The first <see cref="T:Moq.Times"/>. + </param><param name="right"> + The second <see cref="T:Moq.Times"/>. + </param><returns> + <c>true</c> if the value of left is different from the value of right; otherwise, <c>false</c>. + </returns> + </member> + </members> +</doc>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Moq.4.1.1309.1617/lib/sl4/Moq.Silverlight.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,5353 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>Moq.Silverlight</name> + </assembly> + <members> + <member name="T:Moq.Mock`1"> + <summary> + Provides a mock implementation of <typeparamref name="T"/>. + </summary><remarks> + Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. + <para> + The behavior of the mock with regards to the setups and the actual calls is determined + by the optional <see cref="T:Moq.MockBehavior"/> that can be passed to the <see cref="M:Moq.Mock`1.#ctor(Moq.MockBehavior)"/> + constructor. + </para> + </remarks><typeparam name="T">Type to mock, which can be an interface or a class.</typeparam><example group="overview" order="0"> + The following example shows establishing setups with specific values + for method invocations: + <code> + // Arrange + var order = new Order(TALISKER, 50); + var mock = new Mock<IWarehouse>(); + + mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); + + // Act + order.Fill(mock.Object); + + // Assert + Assert.True(order.IsFilled); + </code> + The following example shows how to use the <see cref="T:Moq.It"/> class + to specify conditions for arguments instead of specific values: + <code> + // Arrange + var order = new Order(TALISKER, 50); + var mock = new Mock<IWarehouse>(); + + // shows how to expect a value within a range + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsInRange(0, 100, Range.Inclusive))) + .Returns(false); + + // shows how to throw for unexpected calls. + mock.Setup(x => x.Remove( + It.IsAny<string>(), + It.IsAny<int>())) + .Throws(new InvalidOperationException()); + + // Act + order.Fill(mock.Object); + + // Assert + Assert.False(order.IsFilled); + </code> + </example> + </member> + <member name="T:Moq.Mock"> + <summary> + Base class for mocks and static helper class with methods that + apply to mocked objects, such as <see cref="M:Moq.Mock.Get``1(``0)"/> to + retrieve a <see cref="T:Moq.Mock`1"/> from an object instance. + </summary> + </member> + <member name="T:Moq.IHideObjectMembers"> + <summary> + Helper interface used to hide the base <see cref="T:System.Object"/> + members from the fluent API to make it much cleaner + in Visual Studio intellisense. + </summary> + </member> + <member name="M:Moq.IHideObjectMembers.GetType"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.GetHashCode"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.ToString"> + <summary/> + </member> + <member name="M:Moq.IHideObjectMembers.Equals(System.Object)"> + <summary/> + </member> + <member name="M:Moq.Mock.Of``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mock.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="predicate">The predicate with the specification of how the mocked object should behave.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mock.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:Moq.Mock"/> class. + </summary> + </member> + <member name="M:Moq.Mock.Get``1(``0)"> + <summary> + Retrieves the mock object for the given object instance. + </summary><typeparam name="T"> + Type of the mock to retrieve. Can be omitted as it's inferred + from the object instance passed in as the <paramref name="mocked"/> instance. + </typeparam><param name="mocked">The instance of the mocked object.</param><returns>The mock associated with the mocked object.</returns><exception cref="T:System.ArgumentException"> + The received <paramref name="mocked"/> instance + was not created by Moq. + </exception><example group="advanced"> + The following example shows how to add a new setup to an object + instance which is not the original <see cref="T:Moq.Mock`1"/> but rather + the object associated with it: + <code> + // Typed instance, not the mock, is retrieved from some test API. + HttpContextBase context = GetMockContext(); + + // context.Request is the typed object from the "real" API + // so in order to add a setup to it, we need to get + // the mock that "owns" it + Mock<HttpRequestBase> request = Mock.Get(context.Request); + mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) + .Returns(tempUrl); + </code> + </example> + </member> + <member name="M:Moq.Mock.OnGetObject"> + <summary> + Returns the mocked object value. + </summary> + </member> + <member name="M:Moq.Mock.Verify"> + <summary> + Verifies that all verifiable expectations have been met. + </summary><example group="verification"> + This example sets up an expectation and marks it as verifiable. After + the mock is used, a <c>Verify()</c> call is issued on the mock + to ensure the method in the setup was invoked: + <code> + var mock = new Mock<IWarehouse>(); + this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); + ... + // other test code + ... + // Will throw if the test code has didn't call HasInventory. + this.Verify(); + </code> + </example><exception cref="T:Moq.MockException">Not all verifiable expectations were met.</exception> + </member> + <member name="M:Moq.Mock.VerifyAll"> + <summary> + Verifies all expectations regardless of whether they have + been flagged as verifiable. + </summary><example group="verification"> + This example sets up an expectation without marking it as verifiable. After + the mock is used, a <see cref="M:Moq.Mock.VerifyAll"/> call is issued on the mock + to ensure that all expectations are met: + <code> + var mock = new Mock<IWarehouse>(); + this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); + ... + // other test code + ... + // Will throw if the test code has didn't call HasInventory, even + // that expectation was not marked as verifiable. + this.VerifyAll(); + </code> + </example><exception cref="T:Moq.MockException">At least one expectation was not met.</exception> + </member> + <member name="M:Moq.Mock.GetInterceptor(System.Linq.Expressions.Expression,Moq.Mock)"> + <summary> + Gets the interceptor target for the given expression and root mock, + building the intermediate hierarchy of mock objects if necessary. + </summary> + </member> + <member name="M:Moq.Mock.DoRaise(System.Reflection.EventInfo,System.EventArgs)"> + <summary> + Raises the associated event with the given + event argument data. + </summary> + </member> + <member name="M:Moq.Mock.DoRaise(System.Reflection.EventInfo,System.Object[])"> + <summary> + Raises the associated event with the given + event argument data. + </summary> + </member> + <member name="M:Moq.Mock.As``1"> + <summary> + Adds an interface implementation to the mock, + allowing setups to be specified for it. + </summary><remarks> + This method can only be called before the first use + of the mock <see cref="P:Moq.Mock.Object"/> property, at which + point the runtime type has already been generated + and no more interfaces can be added to it. + <para> + Also, <typeparamref name="TInterface"/> must be an + interface and not a class, which must be specified + when creating the mock instead. + </para> + </remarks><exception cref="T:System.InvalidOperationException"> + The mock type + has already been generated by accessing the <see cref="P:Moq.Mock.Object"/> property. + </exception><exception cref="T:System.ArgumentException"> + The <typeparamref name="TInterface"/> specified + is not an interface. + </exception><example> + The following example creates a mock for the main interface + and later adds <see cref="T:System.IDisposable"/> to it to verify + it's called by the consumer code: + <code> + var mock = new Mock<IProcessor>(); + mock.Setup(x => x.Execute("ping")); + + // add IDisposable interface + var disposable = mock.As<IDisposable>(); + disposable.Setup(d => d.Dispose()).Verifiable(); + </code> + </example><typeparam name="TInterface">Type of interface to cast the mock to.</typeparam> + </member> + <member name="M:Moq.Mock.SetReturnsDefault``1(``0)"> + <!-- No matching elements were found for the following include tag --><include file="Mock.Generic.xdoc" path="docs/doc[@for="Mock.SetReturnDefault{TReturn}"]/*"/> + </member> + <member name="P:Moq.Mock.Behavior"> + <summary> + Behavior of the mock, according to the value set in the constructor. + </summary> + </member> + <member name="P:Moq.Mock.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.Mock.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="P:Moq.Mock.Object"> + <summary> + Gets the mocked object instance. + </summary> + </member> + <member name="P:Moq.Mock.MockedType"> + <summary> + Retrieves the type of the mocked object, its generic type argument. + This is used in the auto-mocking of hierarchy access. + </summary> + </member> + <member name="P:Moq.Mock.DelegateInterfaceMethod"> + <summary> + If this is a mock of a delegate, this property contains the method + on the autogenerated interface so that we can convert setup + verify + expressions on the delegate into expressions on the interface proxy. + </summary> + </member> + <member name="P:Moq.Mock.IsDelegateMock"> + <summary> + Allows to check whether expression conversion to the <see cref="P:Moq.Mock.DelegateInterfaceMethod"/> + must be performed on the mock, without causing unnecessarily early initialization of + the mock instance, which breaks As{T}. + </summary> + </member> + <member name="P:Moq.Mock.DefaultValueProvider"> + <summary> + Specifies the class that will determine the default + value to return when invocations are made that + have no setups and need to return a default + value (for loose mocks). + </summary> + </member> + <member name="P:Moq.Mock.ImplementedInterfaces"> + <summary> + Exposes the list of extra interfaces implemented by the mock. + </summary> + </member> + <member name="T:Moq.IMock`1"> + <summary> + Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> + are possible. Only covers the covariant members of Mock<T>. + </summary> + </member> + <member name="P:Moq.IMock`1.Object"> + <summary> + Exposes the mocked object instance. + </summary> + </member> + <member name="P:Moq.IMock`1.Behavior"> + <summary> + Behavior of the mock, according to the value set in the constructor. + </summary> + </member> + <member name="P:Moq.IMock`1.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.IMock`1.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="M:Moq.Mock`1.#ctor(System.Boolean)"> + <summary> + Ctor invoked by AsTInterface exclusively. + </summary> + </member> + <member name="M:Moq.Mock`1.#ctor"> + <summary> + Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see>. + </summary><example> + <code>var mock = new Mock<IFormatProvider>();</code> + </example> + </member> + <member name="M:Moq.Mock`1.#ctor(System.Object[])"> + <summary> + Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see> and with + the given constructor arguments for the class. (Only valid when <typeparamref name="T"/> is a class) + </summary><remarks> + The mock will try to find the best match constructor given the constructor arguments, and invoke that + to initialize the instance. This applies only for classes, not interfaces. + </remarks><example> + <code>var mock = new Mock<MyProvider>(someArgument, 25);</code> + </example><param name="args">Optional constructor arguments if the mocked type is a class.</param> + </member> + <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior)"> + <summary> + Initializes an instance of the mock with the specified <see cref="T:Moq.MockBehavior">behavior</see>. + </summary><example> + <code>var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed);</code> + </example><param name="behavior">Behavior of the mock.</param> + </member> + <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior,System.Object[])"> + <summary> + Initializes an instance of the mock with a specific <see cref="T:Moq.MockBehavior">behavior</see> with + the given constructor arguments for the class. + </summary><remarks> + The mock will try to find the best match constructor given the constructor arguments, and invoke that + to initialize the instance. This applies only to classes, not interfaces. + </remarks><example> + <code>var mock = new Mock<MyProvider>(someArgument, 25);</code> + </example><param name="behavior">Behavior of the mock.</param><param name="args">Optional constructor arguments if the mocked type is a class.</param> + </member> + <member name="M:Moq.Mock`1.OnGetObject"> + <summary> + Returns the mocked object value. + </summary> + </member> + <member name="M:Moq.Mock`1.Setup(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a void method. + </summary><remarks> + If more than one setup is specified for the same method or property, + the latest one wins and is the one that will be executed. + </remarks><param name="expression">Lambda expression that specifies the expected method invocation.</param><example group="setups"> + <code> + var mock = new Mock<IProcessor>(); + mock.Setup(x => x.Execute("ping")); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Setup``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a value returning method. + </summary><typeparam name="TResult">Type of the return value. Typically omitted as it can be inferred from the expression.</typeparam><remarks> + If more than one setup is specified for the same method or property, + the latest one wins and is the one that will be executed. + </remarks><param name="expression">Lambda expression that specifies the method invocation.</param><example group="setups"> + <code> + mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property getter. + </summary><remarks> + If more than one setup is set for the same property getter, + the latest one wins and is the one that will be executed. + </remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="expression">Lambda expression that specifies the property getter.</param><example group="setups"> + <code> + mock.SetupGet(x => x.Suspended) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupSet``1(System.Action{`0})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter. + </summary><remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + <para> + This overloads allows the use of a callback already + typed for the property type. + </para> + </remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="setterExpression">The Lambda expression that sets a property to a value.</param><example group="setups"> + <code> + mock.SetupSet(x => x.Suspended = true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupSet(System.Action{`0})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter. + </summary><remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + </remarks><param name="setterExpression">Lambda expression that sets a property to a value.</param><example group="setups"> + <code> + mock.SetupSet(x => x.Suspended = true); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Specifies that the given property should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. (this is also + known as "stubbing"). + </summary><typeparam name="TProperty"> + Type of the property, inferred from the property + expression (does not need to be specified). + </typeparam><param name="property">Property expression to stub.</param><example> + If you have an interface with an int property <c>Value</c>, you might + stub it using the following straightforward call: + <code> + var mock = new Mock<IHaveValue>(); + mock.Stub(v => v.Value); + </code> + After the <c>Stub</c> call has been issued, setting and + retrieving the object value will behave as expected: + <code> + IHaveValue v = mock.Object; + + v.Value = 5; + Assert.Equal(5, v.Value); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)"> + <summary> + Specifies that the given property should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. This overload + allows setting the initial value for the property. (this is also + known as "stubbing"). + </summary><typeparam name="TProperty"> + Type of the property, inferred from the property + expression (does not need to be specified). + </typeparam><param name="property">Property expression to stub.</param><param name="initialValue">Initial value for the property.</param><example> + If you have an interface with an int property <c>Value</c>, you might + stub it using the following straightforward call: + <code> + var mock = new Mock<IHaveValue>(); + mock.SetupProperty(v => v.Value, 5); + </code> + After the <c>SetupProperty</c> call has been issued, setting and + retrieving the object value will behave as expected: + <code> + IHaveValue v = mock.Object; + // Initial value was stored + Assert.Equal(5, v.Value); + + // New value set which changes the initial value + v.Value = 6; + Assert.Equal(6, v.Value); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.SetupAllProperties"> + <summary> + Specifies that the all properties on the mock should have "property behavior", + meaning that setting its value will cause it to be saved and + later returned when the property is requested. (this is also + known as "stubbing"). The default value for each property will be the + one generated as specified by the <see cref="P:Moq.Mock.DefaultValue"/> property for the mock. + </summary><remarks> + If the mock <see cref="P:Moq.Mock.DefaultValue"/> is set to <see cref="F:Moq.DefaultValue.Mock"/>, + the mocked default values will also get all properties setup recursively. + </remarks> + </member> + <member name="M:Moq.Mock`1.When(System.Func{System.Boolean})"> + <!-- No matching elements were found for the following include tag --><include file="Mock.Generic.xdoc" path="docs/doc[@for="Mock{T}.When"]/*"/> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IProcessor>(); + // exercise mock + //... + // Will throw if the test code didn't call Execute with a "ping" string argument. + mock.Verify(proc => proc.Execute("ping")); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.Func{Moq.Times})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IProcessor>(); + // exercise mock + //... + // Will throw if the test code didn't call Execute with a "ping" string argument. + mock.Verify(proc => proc.Execute("ping")); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times,System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock, + specifying a failure error message. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Verifies that a specific invocation matching the given expression was performed on the mock. Use + in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><example group="verification"> + This example assumes that the mock has been used, and later we want to verify that a given + invocation with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't call HasInventory. + mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock. Use in conjuntion + with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times})"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock. Use in conjuntion + with the default <see cref="F:Moq.MockBehavior.Loose"/>. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock, specifying a failure + error message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't call HasInventory. + mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)"> + <summary> + Verifies that a specific invocation matching the given + expression was performed on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Verifies that a property was read on the mock. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was retrieved from it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't retrieve the IsClosed property. + mock.VerifyGet(warehouse => warehouse.IsClosed); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)"> + <summary> + Verifies that a property was read on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times})"> + <summary> + Verifies that a property was read on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was retrieved from it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't retrieve the IsClosed property. + mock.VerifyGet(warehouse => warehouse.IsClosed); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a property was read on the mock, specifying a failure + error message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty"> + Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type. + </typeparam> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0})"> + <summary> + Verifies that a property was set on the mock. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was set on it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed = true); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times)"> + <summary> + Verifies that a property was set on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.Func{Moq.Times})"> + <summary> + Verifies that a property was set on the mock. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given property + was set on it: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); + </code> + </example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times,System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.Func{Moq.Times},System.String)"> + <summary> + Verifies that a property was set on the mock, specifying + a failure message. + </summary><exception cref="T:Moq.MockException"> + The invocation was not call the times specified by + <paramref name="times"/>. + </exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param> + </member> + <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.EventArgs)"> + <summary> + Raises the event referenced in <paramref name="eventExpression"/> using + the given <paramref name="args"/> argument. + </summary><exception cref="T:System.ArgumentException"> + The <paramref name="args"/> argument is + invalid for the target event invocation, or the <paramref name="eventExpression"/> is + not an event attach or detach expression. + </exception><example> + The following example shows how to raise a <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event: + <code> + var mock = new Mock<IViewModel>(); + + mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); + </code> + </example><example> + This example shows how to invoke an event with a custom event arguments + class in a view that will cause its corresponding presenter to + react by changing its state: + <code> + var mockView = new Mock<IOrdersView>(); + var presenter = new OrdersPresenter(mockView.Object); + + // Check that the presenter has no selection by default + Assert.Null(presenter.SelectedOrder); + + // Raise the event with a specific arguments data + mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); + + // Now the presenter reacted to the event, and we have a selected order + Assert.NotNull(presenter.SelectedOrder); + Assert.Equal("moq", presenter.SelectedOrder.ProductName); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.Object[])"> + <summary> + Raises the event referenced in <paramref name="eventExpression"/> using + the given <paramref name="args"/> argument for a non-EventHandler typed event. + </summary><exception cref="T:System.ArgumentException"> + The <paramref name="args"/> arguments are + invalid for the target event invocation, or the <paramref name="eventExpression"/> is + not an event attach or detach expression. + </exception><example> + The following example shows how to raise a custom event that does not adhere to + the standard <c>EventHandler</c>: + <code> + var mock = new Mock<IViewModel>(); + + mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); + </code> + </example> + </member> + <member name="M:Moq.Mock`1.Expect(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.Expect``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)"> + <summary> + Obsolete. + </summary> + </member> + <member name="P:Moq.Mock`1.Object"> + <summary> + Exposes the mocked object instance. + </summary> + </member> + <member name="P:Moq.Mock`1.DelegateInterfaceMethod"> + <inheritdoc /> + </member> + <member name="T:Moq.Language.ISetupConditionResult`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.Setup(System.Linq.Expressions.Expression{System.Action{`0}})"> + <summary> + The expectation will be considered only in the former condition. + </summary> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.Setup``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + The expectation will be considered only in the former condition. + </summary> + <typeparam name="TResult"></typeparam> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"> + <summary> + Setups the get. + </summary> + <typeparam name="TProperty">The type of the property.</typeparam> + <param name="expression">The expression.</param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupSet``1(System.Action{`0})"> + <summary> + Setups the set. + </summary> + <typeparam name="TProperty">The type of the property.</typeparam> + <param name="setterExpression">The setter expression.</param> + <returns></returns> + </member> + <member name="M:Moq.Language.ISetupConditionResult`1.SetupSet(System.Action{`0})"> + <summary> + Setups the set. + </summary> + <param name="setterExpression">The setter expression.</param> + <returns></returns> + </member> + <member name="T:Moq.DefaultValue"> + <summary> + Determines the way default values are generated + calculated for loose mocks. + </summary> + </member> + <member name="F:Moq.DefaultValue.Empty"> + <summary> + Default behavior, which generates empty values for + value types (i.e. default(int)), empty array and + enumerables, and nulls for all other reference types. + </summary> + </member> + <member name="F:Moq.DefaultValue.Mock"> + <summary> + Whenever the default value generated by <see cref="F:Moq.DefaultValue.Empty"/> + is null, replaces this value with a mock (if the type + can be mocked). + </summary> + <remarks> + For sealed classes, a null value will be generated. + </remarks> + </member> + <member name="T:Moq.EmptyDefaultValueProvider"> + <summary> + A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value + for invocations that do not have setups or return values, with loose mocks. + This is the default behavior for a mock. + </summary> + </member> + <member name="T:Moq.IDefaultValueProvider"> + <summary> + Interface to be implemented by classes that determine the + default value of non-expected invocations. + </summary> + </member> + <member name="M:Moq.IDefaultValueProvider.DefineDefault``1(``0)"> + <summary> + Defines the default value to return in all the methods returning <typeparamref name="T"/>. + </summary><typeparam name="T">The type of the return value.</typeparam><param name="value">The value to set as default.</param> + </member> + <member name="M:Moq.IDefaultValueProvider.ProvideDefault(System.Reflection.MethodInfo)"> + <summary> + Provides a value for the given member and arguments. + </summary><param name="member"> + The member to provide a default value for. + </param> + </member> + <member name="T:Moq.Evaluator"> + <summary> + Provides partial evaluation of subtrees, whenever they can be evaluated locally. + </summary> + <author>Matt Warren: http://blogs.msdn.com/mattwar</author> + <contributor>Documented by InSTEDD: http://www.instedd.org</contributor> + </member> + <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression,System.Func{System.Linq.Expressions.Expression,System.Boolean})"> + <summary> + Performs evaluation and replacement of independent sub-trees + </summary> + <param name="expression">The root of the expression tree.</param> + <param name="fnCanBeEvaluated">A function that decides whether a given expression + node can be part of the local function.</param> + <returns>A new tree with sub-trees evaluated and replaced.</returns> + </member> + <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression)"> + <summary> + Performs evaluation and replacement of independent sub-trees + </summary> + <param name="expression">The root of the expression tree.</param> + <returns>A new tree with sub-trees evaluated and replaced.</returns> + </member> + <member name="T:Moq.Evaluator.SubtreeEvaluator"> + <summary> + Evaluates and replaces sub-trees when first candidate is reached (top-down) + </summary> + </member> + <member name="T:Moq.Evaluator.Nominator"> + <summary> + Performs bottom-up analysis to determine which nodes can possibly + be part of an evaluated sub-tree. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToLambda(System.Linq.Expressions.Expression)"> + <summary> + Casts the expression to a lambda expression, removing + a cast if there's any. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToMethodCall(System.Linq.Expressions.LambdaExpression)"> + <summary> + Casts the body of the lambda expression to a <see cref="T:System.Linq.Expressions.MethodCallExpression"/>. + </summary> + <exception cref="T:System.ArgumentException">If the body is not a method call.</exception> + </member> + <member name="M:Moq.ExpressionExtensions.ToPropertyInfo(System.Linq.Expressions.LambdaExpression)"> + <summary> + Converts the body of the lambda expression into the <see cref="T:System.Reflection.PropertyInfo"/> referenced by it. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.LambdaExpression)"> + <summary> + Checks whether the body of the lambda expression is a property access. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.Expression)"> + <summary> + Checks whether the expression is a property access. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.LambdaExpression)"> + <summary> + Checks whether the body of the lambda expression is a property indexer, which is true + when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose + <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> + equal to <see langword="true"/>. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.Expression)"> + <summary> + Checks whether the expression is a property indexer, which is true + when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose + <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> + equal to <see langword="true"/>. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.CastTo``1(System.Linq.Expressions.Expression)"> + <summary> + Creates an expression that casts the given expression to the <typeparamref name="T"/> + type. + </summary> + </member> + <member name="M:Moq.ExpressionExtensions.ToStringFixed(System.Linq.Expressions.Expression)"> + <devdoc> + TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 + is fixed. + </devdoc> + </member> + <member name="M:Moq.ExpressionExtensions.GetCallInfo(System.Linq.Expressions.LambdaExpression,Moq.Mock)"> + <summary> + Extracts, into a common form, information from a <see cref="T:System.Linq.Expressions.LambdaExpression"/> + around either a <see cref="T:System.Linq.Expressions.MethodCallExpression"/> (for a normal method call) + or a <see cref="T:System.Linq.Expressions.InvocationExpression"/> (for a delegate invocation). + </summary> + </member> + <member name="T:Moq.ExpressionStringBuilder"> + <summary> + The intention of <see cref="T:Moq.ExpressionStringBuilder"/> is to create a more readable + string representation for the failure message. + </summary> + </member> + <member name="M:Moq.Extensions.IsDelegate(System.Type)"> + <summary> + Tests if a type is a delegate type (subclasses <see cref="T:System.Delegate"/>). + </summary> + </member> + <member name="T:Moq.FluentMockContext"> + <summary> + Tracks the current mock and interception context. + </summary> + </member> + <member name="P:Moq.FluentMockContext.IsActive"> + <summary> + Having an active fluent mock context means that the invocation + is being performed in "trial" mode, just to gather the + target method and arguments that need to be matched later + when the actual invocation is made. + </summary> + </member> + <member name="M:Moq.Guard.NotNull``1(System.Linq.Expressions.Expression{System.Func{``0}},``0)"> + <summary> + Ensures the given <paramref name="value"/> is not null. + Throws <see cref="T:System.ArgumentNullException"/> otherwise. + </summary> + </member> + <member name="M:Moq.Guard.NotNullOrEmpty(System.Linq.Expressions.Expression{System.Func{System.String}},System.String)"> + <summary> + Ensures the given string <paramref name="value"/> is not null or empty. + Throws <see cref="T:System.ArgumentNullException"/> in the first case, or + <see cref="T:System.ArgumentException"/> in the latter. + </summary> + </member> + <member name="M:Moq.Guard.NotOutOfRangeInclusive``1(System.Linq.Expressions.Expression{System.Func{``0}},``0,``0,``0)"> + <summary> + Checks an argument to ensure it is in the specified range including the edges. + </summary> + <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type. + </typeparam> + <param name="reference">The expression containing the name of the argument.</param> + <param name="value">The argument value to check.</param> + <param name="from">The minimun allowed value for the argument.</param> + <param name="to">The maximun allowed value for the argument.</param> + </member> + <member name="M:Moq.Guard.NotOutOfRangeExclusive``1(System.Linq.Expressions.Expression{System.Func{``0}},``0,``0,``0)"> + <summary> + Checks an argument to ensure it is in the specified range excluding the edges. + </summary> + <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type. + </typeparam> + <param name="reference">The expression containing the name of the argument.</param> + <param name="value">The argument value to check.</param> + <param name="from">The minimun allowed value for the argument.</param> + <param name="to">The maximun allowed value for the argument.</param> + </member> + <member name="M:Moq.IInterceptStrategy.HandleIntercept(Moq.Proxy.ICallContext,Moq.InterceptStrategyContext)"> + <summary> + Handle interception + </summary> + <param name="invocation">the current invocation context</param> + <param name="ctx">shared data among the strategies during an interception</param> + <returns>true if further interception has to be processed, otherwise false</returns> + </member> + <member name="T:Moq.IMocked`1"> + <summary> + Implemented by all generated mock object instances. + </summary> + </member> + <member name="T:Moq.IMocked"> + <summary> + Implemented by all generated mock object instances. + </summary> + </member> + <member name="P:Moq.IMocked.Mock"> + <summary> + Reference the Mock that contains this as the <c>mock.Object</c> value. + </summary> + </member> + <member name="P:Moq.IMocked`1.Mock"> + <summary> + Reference the Mock that contains this as the <c>mock.Object</c> value. + </summary> + </member> + <member name="T:Moq.Interceptor"> + <summary> + Implements the actual interception and method invocation for + all mocks. + </summary> + </member> + <member name="M:Moq.AddActualInvocation.GetEventFromName(System.String)"> + <summary> + Get an eventInfo for a given event name. Search type ancestors depth first if necessary. + </summary> + <param name="eventName">Name of the event, with the set_ or get_ prefix already removed</param> + </member> + <member name="M:Moq.AddActualInvocation.GetNonPublicEventFromName(System.String)"> + <summary> + Get an eventInfo for a given event name. Search type ancestors depth first if necessary. + Searches also in non public events. + </summary> + <param name="eventName">Name of the event, with the set_ or get_ prefix already removed</param> + </member> + <member name="M:Moq.AddActualInvocation.GetAncestorTypes(System.Type)"> + <summary> + Given a type return all of its ancestors, both types and interfaces. + </summary> + <param name="initialType">The type to find immediate ancestors of</param> + </member> + <member name="T:Moq.It"> + <summary> + Allows the specification of a matching condition for an + argument in a method invocation, rather than a specific + argument value. "It" refers to the argument being matched. + </summary><remarks> + This class allows the setup to match a method invocation + with an arbitrary value, with a value in a specified range, or + even one that matches a given predicate. + </remarks> + </member> + <member name="M:Moq.It.IsAny``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type. + </summary><remarks> + Typically used when the actual argument value for a method + call is not relevant. + </remarks><example> + <code> + // Throws an exception for a call to Remove with any string value. + mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); + </code> + </example><typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.It.IsNotNull``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type, except null. + </summary><typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.It.Is``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Matches any value that satisfies the given predicate. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="match">The predicate used to match the method argument.</param><remarks> + Allows the specification of a predicate to perform matching + of method call arguments. + </remarks><example> + This example shows how to return the value <c>1</c> whenever the argument to the + <c>Do</c> method is an even number. + <code> + mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) + .Returns(1); + </code> + This example shows how to throw an exception if the argument to the + method is a negative number: + <code> + mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)"> + <summary> + Matches any value that is in the range specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="from">The lower bound of the range.</param><param name="to">The upper bound of the range.</param><param name="rangeKind"> + The kind of range. See <see cref="T:Moq.Range"/>. + </param><example> + The following example shows how to expect a method call + with an integer argument within the 0..100 range. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsInRange(0, 100, Range.Inclusive))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsIn``1(System.Collections.Generic.IEnumerable{``0})"> + <summary> + Matches any value that is present in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of possible values.</param><example> + The following example shows how to expect a method call + with an integer argument with value from a list. + <code> + var values = new List<int> { 1, 2, 3 }; + + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsIn(values))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsIn``1(``0[])"> + <summary> + Matches any value that is present in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of possible values.</param><example> + The following example shows how to expect a method call + with an integer argument with a value of 1, 2, or 3. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsIn(1, 2, 3))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsNotIn``1(System.Collections.Generic.IEnumerable{``0})"> + <summary> + Matches any value that is not found in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of disallowed values.</param><example> + The following example shows how to expect a method call + with an integer argument with value not found from a list. + <code> + var values = new List<int> { 1, 2, 3 }; + + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsNotIn(values))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsNotIn``1(``0[])"> + <summary> + Matches any value that is not found in the sequence specified. + </summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="items">The sequence of disallowed values.</param><example> + The following example shows how to expect a method call + with an integer argument of any value except 1, 2, or 3. + <code> + mock.Setup(x => x.HasInventory( + It.IsAny<string>(), + It.IsNotIn(1, 2, 3))) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.It.IsRegex(System.String)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary><param name="regex">The pattern to use to match the string argument value.</param><example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression: + <code> + mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); + </code> + </example> + </member> + <member name="M:Moq.It.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary><param name="regex">The pattern to use to match the string argument value.</param><param name="options">The options used to interpret the pattern.</param><example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression, in a case insensitive way: + <code> + mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IReturnsResult`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallback"> + <summary> + Defines the <c>Callback</c> verb and overloads. + </summary> + </member> + <member name="M:Moq.Language.ICallback.Callback``2(System.Action{``0,``1})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``3(System.Action{``0,``1,``2})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``4(System.Action{``0,``1,``2,``3})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``5(System.Action{``0,``1,``2,``3,``4})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``6(System.Action{``0,``1,``2,``3,``4,``5})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``7(System.Action{``0,``1,``2,``3,``4,``5,``6})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``8(System.Action{``0,``1,``2,``3,``4,``5,``6,``7})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``9(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``10(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``11(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``12(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``13(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``14(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``15(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``16(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.ICallbackResult"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the method is called. + </summary> + <param name="action">The callback method to invoke.</param> + <example> + The following example specifies a callback to set a boolean + value that can be used later: + <code> + var called = false; + mock.Setup(x => x.Execute()) + .Callback(() => called = true); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback.Callback``1(System.Action{``0})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T">The argument type of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <example> + Invokes the given callback with the concrete invocation argument value. + <para> + Notice how the specific string argument is retrieved by simply declaring + it as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Callback((string command) => Console.WriteLine(command)); + </code> + </example> + </member> + <member name="T:Moq.Language.IOccurrence"> + <summary> + Defines occurrence members to constraint setups. + </summary> + </member> + <member name="M:Moq.Language.IOccurrence.AtMostOnce"> + <summary> + The expected invocation can happen at most once. + </summary> + <example> + <code> + var mock = new Mock<ICommand>(); + mock.Setup(foo => foo.Execute("ping")) + .AtMostOnce(); + </code> + </example> + </member> + <member name="M:Moq.Language.IOccurrence.AtMost(System.Int32)"> + <summary> + The expected invocation can happen at most specified number of times. + </summary> + <param name="callCount">The number of times to accept calls.</param> + <example> + <code> + var mock = new Mock<ICommand>(); + mock.Setup(foo => foo.Execute("ping")) + .AtMost( 5 ); + </code> + </example> + </member> + <member name="T:Moq.Language.IRaise`1"> + <summary> + Defines the <c>Raises</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"> + <summary> + Specifies the event that will be raised + when the setup is met. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="args">The event arguments to pass for the raised event.</param> + <example> + The following example shows how to raise an event when + the setup is met: + <code> + var mock = new Mock<IContainer>(); + + mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) + .Raises(add => add.Added += null, EventArgs.Empty); + </code> + </example> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Func{System.EventArgs})"> + <summary> + Specifies the event that will be raised + when the setup is matched. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="func">A function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Object[])"> + <summary> + Specifies the custom event that will be raised + when the setup is matched. + </summary> + <param name="eventExpression">An expression that represents an event attach or detach action.</param> + <param name="args">The arguments to pass to the custom delegate (non EventHandler-compatible).</param> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``1(System.Action{`0},System.Func{``0,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``2(System.Action{`0},System.Func{``0,``1,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``3(System.Action{`0},System.Func{``0,``1,``2,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``4(System.Action{`0},System.Func{``0,``1,``2,``3,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``5(System.Action{`0},System.Func{``0,``1,``2,``3,``4,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``6(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``7(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``8(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``9(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``10(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``11(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``12(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``13(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``14(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``15(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <typeparam name="T15">The type of the fifteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="M:Moq.Language.IRaise`1.Raises``16(System.Action{`0},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15,System.EventArgs})"> + <summary> + Specifies the event that will be raised when the setup is matched. + </summary> + <param name="eventExpression">The expression that represents an event attach or detach action.</param> + <param name="func">The function that will build the <see cref="T:System.EventArgs"/> + to pass when raising the event.</param> + <typeparam name="T1">The type of the first argument received by the expected invocation.</typeparam> + <typeparam name="T2">The type of the second argument received by the expected invocation.</typeparam> + <typeparam name="T3">The type of the third argument received by the expected invocation.</typeparam> + <typeparam name="T4">The type of the fourth argument received by the expected invocation.</typeparam> + <typeparam name="T5">The type of the fifth argument received by the expected invocation.</typeparam> + <typeparam name="T6">The type of the sixth argument received by the expected invocation.</typeparam> + <typeparam name="T7">The type of the seventh argument received by the expected invocation.</typeparam> + <typeparam name="T8">The type of the eighth argument received by the expected invocation.</typeparam> + <typeparam name="T9">The type of the nineth argument received by the expected invocation.</typeparam> + <typeparam name="T10">The type of the tenth argument received by the expected invocation.</typeparam> + <typeparam name="T11">The type of the eleventh argument received by the expected invocation.</typeparam> + <typeparam name="T12">The type of the twelfth argument received by the expected invocation.</typeparam> + <typeparam name="T13">The type of the thirteenth argument received by the expected invocation.</typeparam> + <typeparam name="T14">The type of the fourteenth argument received by the expected invocation.</typeparam> + <typeparam name="T15">The type of the fifteenth argument received by the expected invocation.</typeparam> + <typeparam name="T16">The type of the sixteenth argument received by the expected invocation.</typeparam> + <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/> + </member> + <member name="T:Moq.Language.IVerifies"> + <summary> + Defines the <c>Verifiable</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IVerifies.Verifiable"> + <summary> + Marks the expectation as verifiable, meaning that a call + to <see cref="M:Moq.Mock.Verify"/> will check if this particular + expectation was met. + </summary> + <example> + The following example marks the expectation as verifiable: + <code> + mock.Expect(x => x.Execute("ping")) + .Returns(true) + .Verifiable(); + </code> + </example> + </member> + <member name="M:Moq.Language.IVerifies.Verifiable(System.String)"> + <summary> + Marks the expectation as verifiable, meaning that a call + to <see cref="M:Moq.Mock.Verify"/> will check if this particular + expectation was met, and specifies a message for failures. + </summary> + <example> + The following example marks the expectation as verifiable: + <code> + mock.Expect(x => x.Execute("ping")) + .Returns(true) + .Verifiable("Ping should be executed always!"); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.ISetup`1"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.Flow.ICallbackResult"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IThrows"> + <summary> + Defines the <c>Throws</c> verb. + </summary> + </member> + <member name="M:Moq.Language.IThrows.Throws(System.Exception)"> + <summary> + Specifies the exception to throw when the method is invoked. + </summary> + <param name="exception">Exception instance to throw.</param> + <example> + This example shows how to throw an exception when the method is + invoked with an empty string argument: + <code> + mock.Setup(x => x.Execute("")) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.Language.IThrows.Throws``1"> + <summary> + Specifies the type of exception to throw when the method is invoked. + </summary> + <typeparam name="TException">Type of exception to instantiate and throw when the setup is matched.</typeparam> + <example> + This example shows how to throw an exception when the method is + invoked with an empty string argument: + <code> + mock.Setup(x => x.Execute("")) + .Throws<ArgumentException>(); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IThrowsResult"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.Flow.ISetup`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallback`2"> + <summary> + Defines the <c>Callback</c> verb and overloads for callbacks on + setups that return a value. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TResult">Type of the return value of the setup.</typeparam> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``2(System.Action{``0,``1})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``3(System.Action{``0,``1,``2})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``4(System.Action{``0,``1,``2,``3})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``5(System.Action{``0,``1,``2,``3,``4})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``6(System.Action{``0,``1,``2,``3,``4,``5})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``7(System.Action{``0,``1,``2,``3,``4,``5,``6})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``8(System.Action{``0,``1,``2,``3,``4,``5,``6,``7})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``9(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``10(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``11(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``12(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``13(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``14(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``15(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``16(System.Action{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original + arguments. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="action">The callback method to invoke.</param> + <returns>A reference to <see cref="T:Moq.Language.Flow.IReturnsThrows`2"/> interface.</returns> + <example> + Invokes the given callback with the concrete invocation arguments values. + <para> + Notice how the specific arguments are retrieved by simply declaring + them as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>(), + It.IsAny<string>())) + .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); + </code> + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the method is called. + </summary> + <param name="action">The callback method to invoke.</param> + <example> + The following example specifies a callback to set a boolean value that can be used later: + <code> + var called = false; + mock.Setup(x => x.Execute()) + .Callback(() => called = true) + .Returns(true); + </code> + Note that in the case of value-returning methods, after the <c>Callback</c> + call you can still specify the return value. + </example> + </member> + <member name="M:Moq.Language.ICallback`2.Callback``1(System.Action{``0})"> + <summary> + Specifies a callback to invoke when the method is called that receives the original arguments. + </summary> + <typeparam name="T">The type of the argument of the invoked method.</typeparam> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the concrete invocation argument value. + <para> + Notice how the specific string argument is retrieved by simply declaring + it as part of the lambda expression for the callback: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Callback(command => Console.WriteLine(command)) + .Returns(true); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IReturnsThrows`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IReturns`2"> + <summary> + Defines the <c>Returns</c> verb. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TResult">Type of the return value from the expression.</typeparam> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``2(System.Func{``0,``1,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2) => arg1 + arg2); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``3(System.Func{``0,``1,``2,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``4(System.Func{``0,``1,``2,``3,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``5(System.Func{``0,``1,``2,``3,``4,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``6(System.Func{``0,``1,``2,``3,``4,``5,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``7(System.Func{``0,``1,``2,``3,``4,``5,``6,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``8(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``9(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``10(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``11(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``12(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``13(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``14(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``15(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``16(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T1">The type of the first argument of the invoked method.</typeparam> + <typeparam name="T2">The type of the second argument of the invoked method.</typeparam> + <typeparam name="T3">The type of the third argument of the invoked method.</typeparam> + <typeparam name="T4">The type of the fourth argument of the invoked method.</typeparam> + <typeparam name="T5">The type of the fifth argument of the invoked method.</typeparam> + <typeparam name="T6">The type of the sixth argument of the invoked method.</typeparam> + <typeparam name="T7">The type of the seventh argument of the invoked method.</typeparam> + <typeparam name="T8">The type of the eighth argument of the invoked method.</typeparam> + <typeparam name="T9">The type of the nineth argument of the invoked method.</typeparam> + <typeparam name="T10">The type of the tenth argument of the invoked method.</typeparam> + <typeparam name="T11">The type of the eleventh argument of the invoked method.</typeparam> + <typeparam name="T12">The type of the twelfth argument of the invoked method.</typeparam> + <typeparam name="T13">The type of the thirteenth argument of the invoked method.</typeparam> + <typeparam name="T14">The type of the fourteenth argument of the invoked method.</typeparam> + <typeparam name="T15">The type of the fifteenth argument of the invoked method.</typeparam> + <typeparam name="T16">The type of the sixteenth argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <return>Returns a calculated value which is evaluated lazily at the time of the invocation.</return> + <example> + <para> + The return value is calculated from the value of the actual method invocation arguments. + Notice how the arguments are retrieved by simply declaring them as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute( + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>(), + It.IsAny<int>())) + .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns(`1)"> + <summary> + Specifies the value to return. + </summary> + <param name="value">The value to return, or <see langword="null"/>.</param> + <example> + Return a <c>true</c> value from the method call: + <code> + mock.Setup(x => x.Execute("ping")) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns(System.Func{`1})"> + <summary> + Specifies a function that will calculate the value to return from the method. + </summary> + <param name="valueFunction">The function that will calculate the return value.</param> + <example group="returns"> + Return a calculated value when the method is called: + <code> + mock.Setup(x => x.Execute("ping")) + .Returns(() => returnValues[0]); + </code> + The lambda expression to retrieve the return value is lazy-executed, + meaning that its value may change depending on the moment the method + is executed and the value the <c>returnValues</c> array has at + that moment. + </example> + </member> + <member name="M:Moq.Language.IReturns`2.Returns``1(System.Func{``0,`1})"> + <summary> + Specifies a function that will calculate the value to return from the method, + retrieving the arguments for the invocation. + </summary> + <typeparam name="T">The type of the argument of the invoked method.</typeparam> + <param name="valueFunction">The function that will calculate the return value.</param> + <example group="returns"> + Return a calculated value which is evaluated lazily at the time of the invocation. + <para> + The lookup list can change between invocations and the setup + will return different values accordingly. Also, notice how the specific + string argument is retrieved by simply declaring it as part of the lambda + expression: + </para> + <code> + mock.Setup(x => x.Execute(It.IsAny<string>())) + .Returns((string command) => returnValues[command]); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturns`2.CallBase"> + <summary> + Calls the real method of the object and returns its return value. + </summary> + <returns>The value calculated by the real method of the object.</returns> + </member> + <member name="T:Moq.Language.Flow.ISetupGetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallbackGetter`2"> + <summary> + Defines the <c>Callback</c> verb for property getter setups. + </summary> + <seealso cref="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"/> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.ICallbackGetter`2.Callback(System.Action)"> + <summary> + Specifies a callback to invoke when the property is retrieved. + </summary> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the property value being set. + <code> + mock.SetupGet(x => x.Suspended) + .Callback(() => called = true) + .Returns(true); + </code> + </example> + </member> + <member name="T:Moq.Language.Flow.IReturnsThrowsGetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.IReturnsGetter`2"> + <summary> + Defines the <c>Returns</c> verb for property get setups. + </summary> + <typeparam name="TMock">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.Returns(`1)"> + <summary> + Specifies the value to return. + </summary> + <param name="value">The value to return, or <see langword="null"/>.</param> + <example> + Return a <c>true</c> value from the property getter call: + <code> + mock.SetupGet(x => x.Suspended) + .Returns(true); + </code> + </example> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.Returns(System.Func{`1})"> + <summary> + Specifies a function that will calculate the value to return for the property. + </summary> + <param name="valueFunction">The function that will calculate the return value.</param> + <example> + Return a calculated value when the property is retrieved: + <code> + mock.SetupGet(x => x.Suspended) + .Returns(() => returnValues[0]); + </code> + The lambda expression to retrieve the return value is lazy-executed, + meaning that its value may change depending on the moment the property + is retrieved and the value the <c>returnValues</c> array has at + that moment. + </example> + </member> + <member name="M:Moq.Language.IReturnsGetter`2.CallBase"> + <summary> + Calls the real property of the object and returns its return value. + </summary> + <returns>The value calculated by the real property of the object.</returns> + </member> + <member name="T:Moq.Language.Flow.ISetupSetter`2"> + <summary> + Implements the fluent API. + </summary> + </member> + <member name="T:Moq.Language.ICallbackSetter`1"> + <summary> + Defines the <c>Callback</c> verb for property setter setups. + </summary> + <typeparam name="TProperty">Type of the property.</typeparam> + </member> + <member name="M:Moq.Language.ICallbackSetter`1.Callback(System.Action{`0})"> + <summary> + Specifies a callback to invoke when the property is set that receives the + property value being set. + </summary> + <param name="action">Callback method to invoke.</param> + <example> + Invokes the given callback with the property value being set. + <code> + mock.SetupSet(x => x.Suspended) + .Callback((bool state) => Console.WriteLine(state)); + </code> + </example> + </member> + <member name="T:Moq.Language.ISetupSequentialResult`1"> + <summary> + Language for ReturnSequence + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Returns(`0)"> + <summary> + Returns value + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Throws(System.Exception)"> + <summary> + Throws an exception + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.Throws``1"> + <summary> + Throws an exception + </summary> + </member> + <member name="M:Moq.Language.ISetupSequentialResult`1.CallBase"> + <summary> + Calls original method + </summary> + </member> + <member name="F:Moq.Linq.FluentMockVisitor.isFirst"> + <summary> + The first method call or member access will be the + last segment of the expression (depth-first traversal), + which is the one we have to Setup rather than FluentMock. + And the last one is the one we have to Mock.Get rather + than FluentMock. + </summary> + </member> + <member name="T:Moq.Linq.MockQueryable`1"> + <summary> + A default implementation of IQueryable for use with QueryProvider + </summary> + </member> + <member name="M:Moq.Linq.MockQueryable`1.#ctor(System.Linq.Expressions.MethodCallExpression)"> + <summary> + The <paramref name="underlyingCreateMocks"/> is a + static method that returns an IQueryable of Mocks of T which is used to + apply the linq specification to. + </summary> + </member> + <member name="T:Moq.MockRepository"> + <summary> + Utility repository class to use to construct multiple + mocks when consistent verification is + desired for all of them. + </summary> + <remarks> + If multiple mocks will be created during a test, passing + the desired <see cref="T:Moq.MockBehavior"/> (if different than the + <see cref="F:Moq.MockBehavior.Default"/> or the one + passed to the repository constructor) and later verifying each + mock can become repetitive and tedious. + <para> + This repository class helps in that scenario by providing a + simplified creation of multiple mocks with a default + <see cref="T:Moq.MockBehavior"/> (unless overriden by calling + <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/>) and posterior verification. + </para> + </remarks> + <example group="repository"> + The following is a straightforward example on how to + create and automatically verify strict mocks using a <see cref="T:Moq.MockRepository"/>: + <code> + var repository = new MockRepository(MockBehavior.Strict); + + var foo = repository.Create<IFoo>(); + var bar = repository.Create<IBar>(); + + // no need to call Verifiable() on the setup + // as we'll be validating all of them anyway. + foo.Setup(f => f.Do()); + bar.Setup(b => b.Redo()); + + // exercise the mocks here + + repository.VerifyAll(); + // At this point all setups are already checked + // and an optional MockException might be thrown. + // Note also that because the mocks are strict, any invocation + // that doesn't have a matching setup will also throw a MockException. + </code> + The following examples shows how to setup the repository + to create loose mocks and later verify only verifiable setups: + <code> + var repository = new MockRepository(MockBehavior.Loose); + + var foo = repository.Create<IFoo>(); + var bar = repository.Create<IBar>(); + + // this setup will be verified when we verify the repository + foo.Setup(f => f.Do()).Verifiable(); + + // this setup will NOT be verified + foo.Setup(f => f.Calculate()); + + // this setup will be verified when we verify the repository + bar.Setup(b => b.Redo()).Verifiable(); + + // exercise the mocks here + // note that because the mocks are Loose, members + // called in the interfaces for which no matching + // setups exist will NOT throw exceptions, + // and will rather return default values. + + repository.Verify(); + // At this point verifiable setups are already checked + // and an optional MockException might be thrown. + </code> + The following examples shows how to setup the repository with a + default strict behavior, overriding that default for a + specific mock: + <code> + var repository = new MockRepository(MockBehavior.Strict); + + // this particular one we want loose + var foo = repository.Create<IFoo>(MockBehavior.Loose); + var bar = repository.Create<IBar>(); + + // specify setups + + // exercise the mocks here + + repository.Verify(); + </code> + </example> + <seealso cref="T:Moq.MockBehavior"/> + </member> + <member name="T:Moq.MockFactory"> + <summary> + Utility factory class to use to construct multiple + mocks when consistent verification is + desired for all of them. + </summary> + <remarks> + If multiple mocks will be created during a test, passing + the desired <see cref="T:Moq.MockBehavior"/> (if different than the + <see cref="F:Moq.MockBehavior.Default"/> or the one + passed to the factory constructor) and later verifying each + mock can become repetitive and tedious. + <para> + This factory class helps in that scenario by providing a + simplified creation of multiple mocks with a default + <see cref="T:Moq.MockBehavior"/> (unless overriden by calling + <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/>) and posterior verification. + </para> + </remarks> + <example group="factory"> + The following is a straightforward example on how to + create and automatically verify strict mocks using a <see cref="T:Moq.MockFactory"/>: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(); + var bar = factory.Create<IBar>(); + + // no need to call Verifiable() on the setup + // as we'll be validating all of them anyway. + foo.Setup(f => f.Do()); + bar.Setup(b => b.Redo()); + + // exercise the mocks here + + factory.VerifyAll(); + // At this point all setups are already checked + // and an optional MockException might be thrown. + // Note also that because the mocks are strict, any invocation + // that doesn't have a matching setup will also throw a MockException. + </code> + The following examples shows how to setup the factory + to create loose mocks and later verify only verifiable setups: + <code> + var factory = new MockFactory(MockBehavior.Loose); + + var foo = factory.Create<IFoo>(); + var bar = factory.Create<IBar>(); + + // this setup will be verified when we verify the factory + foo.Setup(f => f.Do()).Verifiable(); + + // this setup will NOT be verified + foo.Setup(f => f.Calculate()); + + // this setup will be verified when we verify the factory + bar.Setup(b => b.Redo()).Verifiable(); + + // exercise the mocks here + // note that because the mocks are Loose, members + // called in the interfaces for which no matching + // setups exist will NOT throw exceptions, + // and will rather return default values. + + factory.Verify(); + // At this point verifiable setups are already checked + // and an optional MockException might be thrown. + </code> + The following examples shows how to setup the factory with a + default strict behavior, overriding that default for a + specific mock: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + // this particular one we want loose + var foo = factory.Create<IFoo>(MockBehavior.Loose); + var bar = factory.Create<IBar>(); + + // specify setups + + // exercise the mocks here + + factory.Verify(); + </code> + </example> + <seealso cref="T:Moq.MockBehavior"/> + </member> + <member name="M:Moq.MockFactory.#ctor(Moq.MockBehavior)"> + <summary> + Initializes the factory with the given <paramref name="defaultBehavior"/> + for newly created mocks from the factory. + </summary> + <param name="defaultBehavior">The behavior to use for mocks created + using the <see cref="M:Moq.MockFactory.Create``1"/> factory method if not overriden + by using the <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/> overload.</param> + </member> + <member name="M:Moq.MockFactory.Create``1"> + <summary> + Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> + specified at factory construction time. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example ignore="true"> + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(); + // use mock on tests + + factory.VerifyAll(); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(System.Object[])"> + <summary> + Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> + specified at factory construction time and with the + the given constructor arguments for the class. + </summary> + <remarks> + The mock will try to find the best match constructor given the + constructor arguments, and invoke that to initialize the instance. + This applies only to classes, not interfaces. + </remarks> + <typeparam name="T">Type to mock.</typeparam> + <param name="args">Constructor arguments for mocked classes.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example ignore="true"> + <code> + var factory = new MockFactory(MockBehavior.Default); + + var mock = factory.Create<MyBase>("Foo", 25, true); + // use mock on tests + + factory.Verify(); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"> + <summary> + Creates a new mock with the given <paramref name="behavior"/>. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">Behavior to use for the mock, which overrides + the default behavior specified at factory construction time.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example group="factory"> + The following example shows how to create a mock with a different + behavior to that specified as the default for the factory: + <code> + var factory = new MockFactory(MockBehavior.Strict); + + var foo = factory.Create<IFoo>(MockBehavior.Loose); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior,System.Object[])"> + <summary> + Creates a new mock with the given <paramref name="behavior"/> + and with the the given constructor arguments for the class. + </summary> + <remarks> + The mock will try to find the best match constructor given the + constructor arguments, and invoke that to initialize the instance. + This applies only to classes, not interfaces. + </remarks> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">Behavior to use for the mock, which overrides + the default behavior specified at factory construction time.</param> + <param name="args">Constructor arguments for mocked classes.</param> + <returns>A new <see cref="T:Moq.Mock`1"/>.</returns> + <example group="factory"> + The following example shows how to create a mock with a different + behavior to that specified as the default for the factory, passing + constructor arguments: + <code> + var factory = new MockFactory(MockBehavior.Default); + + var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); + </code> + </example> + </member> + <member name="M:Moq.MockFactory.CreateMock``1(Moq.MockBehavior,System.Object[])"> + <summary> + Implements creation of a new mock within the factory. + </summary> + <typeparam name="T">Type to mock.</typeparam> + <param name="behavior">The behavior for the new mock.</param> + <param name="args">Optional arguments for the construction of the mock.</param> + </member> + <member name="M:Moq.MockFactory.Verify"> + <summary> + Verifies all verifiable expectations on all mocks created + by this factory. + </summary> + <seealso cref="M:Moq.Mock.Verify"/> + <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception> + </member> + <member name="M:Moq.MockFactory.VerifyAll"> + <summary> + Verifies all verifiable expectations on all mocks created + by this factory. + </summary> + <seealso cref="M:Moq.Mock.Verify"/> + <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception> + </member> + <member name="M:Moq.MockFactory.VerifyMocks(System.Action{Moq.Mock})"> + <summary> + Invokes <paramref name="verifyAction"/> for each mock + in <see cref="P:Moq.MockFactory.Mocks"/>, and accumulates the resulting + <see cref="T:Moq.MockVerificationException"/> that might be + thrown from the action. + </summary> + <param name="verifyAction">The action to execute against + each mock.</param> + </member> + <member name="P:Moq.MockFactory.CallBase"> + <summary> + Whether the base member virtual implementation will be called + for mocked classes if no setup is matched. Defaults to <see langword="false"/>. + </summary> + </member> + <member name="P:Moq.MockFactory.DefaultValue"> + <summary> + Specifies the behavior to use when returning default values for + unexpected invocations on loose mocks. + </summary> + </member> + <member name="P:Moq.MockFactory.Mocks"> + <summary> + Gets the mocks that have been created by this factory and + that will get verified together. + </summary> + </member> + <member name="M:Moq.MockRepository.Of``1"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.MockRepository.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.MockRepository.OneOf``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.MockRepository.OneOf``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.MockRepository.CreateMockQuery``1"> + <summary> + Creates the mock query with the underlying queriable implementation. + </summary> + </member> + <member name="M:Moq.MockRepository.CreateQueryable``1"> + <summary> + Wraps the enumerator inside a queryable. + </summary> + </member> + <member name="M:Moq.MockRepository.CreateMocks``1"> + <summary> + Method that is turned into the actual call from .Query{T}, to + transform the queryable query into a normal enumerable query. + This method is never used directly by consumers. + </summary> + </member> + <member name="M:Moq.MockRepository.#ctor(Moq.MockBehavior)"> + <summary> + Initializes the repository with the given <paramref name="defaultBehavior"/> + for newly created mocks from the repository. + </summary> + <param name="defaultBehavior">The behavior to use for mocks created + using the <see cref="M:Moq.MockFactory.Create``1"/> repository method if not overriden + by using the <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/> overload.</param> + </member> + <member name="T:Moq.Mocks"> + <summary> + Allows querying the universe of mocks for those that behave + according to the LINQ query specification. + </summary> + <devdoc> + This entry-point into Linq to Mocks is the only one in the root Moq + namespace to ease discovery. But to get all the mocking extension + methods on Object, a using of Moq.Linq must be done, so that the + polluting of the intellisense for all objects is an explicit opt-in. + </devdoc> + </member> + <member name="M:Moq.Mocks.Of``1"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.Mocks.Of``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Access the universe of mocks of the given type, to retrieve those + that behave according to the LINQ query specification. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object to query.</typeparam> + </member> + <member name="M:Moq.Mocks.OneOf``1"> + <summary> + Creates an mock object of the indicated type. + </summary> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mocks.OneOf``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Creates an mock object of the indicated type. + </summary> + <param name="specification">The predicate with the setup expressions.</param> + <typeparam name="T">The type of the mocked object.</typeparam> + <returns>The mocked object created.</returns> + </member> + <member name="M:Moq.Mocks.CreateMockQuery``1"> + <summary> + Creates the mock query with the underlying queriable implementation. + </summary> + </member> + <member name="M:Moq.Mocks.CreateQueryable``1"> + <summary> + Wraps the enumerator inside a queryable. + </summary> + </member> + <member name="M:Moq.Mocks.CreateMocks``1"> + <summary> + Method that is turned into the actual call from .Query{T}, to + transform the queryable query into a normal enumerable query. + This method is never used directly by consumers. + </summary> + </member> + <member name="M:Moq.Mocks.SetPropery``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Extension method used to support Linq-like setup properties that are not virtual but do have + a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) + </summary> + </member> + <member name="T:Moq.QueryableMockExtensions"> + <summary> + Helper extensions that are used by the query translator. + </summary> + </member> + <member name="M:Moq.QueryableMockExtensions.FluentMock``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Retrieves a fluent mock from the given setup expression. + </summary> + </member> + <member name="T:Moq.Match"> + <summary> + Allows creation custom value matchers that can be used on setups and verification, + completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary><remarks> + See also <see cref="T:Moq.Match`1"/>. + </remarks> + </member> + <member name="M:Moq.Match.Matcher``1"> + <devdoc> + Provided for the sole purpose of rendering the delegate passed to the + matcher constructor if no friendly render lambda is provided. + </devdoc> + </member> + <member name="M:Moq.Match.Create``1(System.Predicate{``0})"> + <summary> + Initializes the match with the condition that + will be checked in order to match invocation + values. + </summary><param name="condition">The condition to match against actual values.</param><remarks> + <seealso cref="T:Moq.Match`1"/> + </remarks> + </member> + <member name="M:Moq.Match.Create``1(System.Predicate{``0},System.Linq.Expressions.Expression{System.Func{``0}})"> + <!-- No matching elements were found for the following include tag --><include file="Match.xdoc" path="docs/doc[@for="Match.Create{T}(condition,renderExpression"]/*"/> + </member> + <member name="M:Moq.Match.SetLastMatch``1(Moq.Match{``0})"> + <devdoc> + This method is used to set an expression as the last matcher invoked, + which is used in the SetupSet to allow matchers in the prop = value + delegate expression. This delegate is executed in "fluent" mode in + order to capture the value being set, and construct the corresponding + methodcall. + This is also used in the MatcherFactory for each argument expression. + This method ensures that when we execute the delegate, we + also track the matcher that was invoked, so that when we create the + methodcall we build the expression using it, rather than the null/default + value returned from the actual invocation. + </devdoc> + </member> + <member name="T:Moq.Match`1"> + <summary> + Allows creation custom value matchers that can be used on setups and verification, + completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary><typeparam name="T">Type of the value to match.</typeparam><remarks> + The argument matching is used to determine whether a concrete + invocation in the mock matches a given setup. This + matching mechanism is fully extensible. + </remarks><example> + Creating a custom matcher is straightforward. You just need to create a method + that returns a value from a call to <see cref="M:Moq.Match.Create``1(System.Predicate{``0})"/> with + your matching condition and optional friendly render expression: + <code> + [Matcher] + public Order IsBigOrder() + { + return Match<Order>.Create( + o => o.GrandTotal >= 5000, + /* a friendly expression to render on failures */ + () => IsBigOrder()); + } + </code> + This method can be used in any mock setup invocation: + <code> + mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); + </code> + At runtime, Moq knows that the return value was a matcher (note that the method MUST be + annotated with the [Matcher] attribute in order to determine this) and + evaluates your predicate with the actual value passed into your predicate. + <para> + Another example might be a case where you want to match a lists of orders + that contains a particular one. You might create matcher like the following: + </para> + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); + } + } + </code> + Now we can invoke this static method instead of an argument in an + invocation: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + </code> + </example> + </member> + <member name="T:Moq.MatcherAttribute"> + <summary> + Marks a method as a matcher, which allows complete replacement + of the built-in <see cref="T:Moq.It"/> class with your own argument + matching rules. + </summary> + <remarks> + <b>This feature has been deprecated in favor of the new + and simpler <see cref="T:Moq.Match`1"/>. + </b> + <para> + The argument matching is used to determine whether a concrete + invocation in the mock matches a given setup. This + matching mechanism is fully extensible. + </para> + <para> + There are two parts of a matcher: the compiler matcher + and the runtime matcher. + <list type="bullet"> + <item> + <term>Compiler matcher</term> + <description>Used to satisfy the compiler requirements for the + argument. Needs to be a method optionally receiving any arguments + you might need for the matching, but with a return type that + matches that of the argument. + <para> + Let's say I want to match a lists of orders that contains + a particular one. I might create a compiler matcher like the following: + </para> + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return null; + } + } + </code> + Now we can invoke this static method instead of an argument in an + invocation: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + </code> + Note that the return value from the compiler matcher is irrelevant. + This method will never be called, and is just used to satisfy the + compiler and to signal Moq that this is not a method that we want + to be invoked at runtime. + </description> + </item> + <item> + <term>Runtime matcher</term> + <description> + The runtime matcher is the one that will actually perform evaluation + when the test is run, and is defined by convention to have the + same signature as the compiler matcher, but where the return + value is the first argument to the call, which contains the + object received by the actual invocation at runtime: + <code> + public static bool Contains(IEnumerable<Order> orders, Order order) + { + return orders.Contains(order); + } + </code> + At runtime, the mocked method will be invoked with a specific + list of orders. This value will be passed to this runtime + matcher as the first argument, while the second argument is the + one specified in the setup (<c>x.Save(Orders.Contains(order))</c>). + <para> + The boolean returned determines whether the given argument has been + matched. If all arguments to the expected method are matched, then + the setup matches and is evaluated. + </para> + </description> + </item> + </list> + </para> + Using this extensible infrastructure, you can easily replace the entire + <see cref="T:Moq.It"/> set of matchers with your own. You can also avoid the + typical (and annoying) lengthy expressions that result when you have + multiple arguments that use generics. + </remarks> + <example> + The following is the complete example explained above: + <code> + public static class Orders + { + [Matcher] + public static IEnumerable<Order> Contains(Order order) + { + return null; + } + + public static bool Contains(IEnumerable<Order> orders, Order order) + { + return orders.Contains(order); + } + } + </code> + And the concrete test using this matcher: + <code> + var order = new Order { ... }; + var mock = new Mock<IRepository<Order>>(); + + mock.Setup(x => x.Save(Orders.Contains(order))) + .Throws<ArgumentException>(); + + // use mock, invoke Save, and have the matcher filter. + </code> + </example> + </member> + <member name="T:Moq.Matchers.MatcherAttributeMatcher"> + <summary> + Matcher to treat static functions as matchers. + + mock.Setup(x => x.StringMethod(A.MagicString())); + + public static class A + { + [Matcher] + public static string MagicString() { return null; } + public static bool MagicString(string arg) + { + return arg == "magic"; + } + } + + Will succeed if: mock.Object.StringMethod("magic"); + and fail with any other call. + </summary> + </member> + <member name="T:Moq.MethodCallReturn"> + <devdoc> + We need this non-generics base class so that + we can use <see cref="P:Moq.MethodCallReturn.HasReturnValue"/> from + generic code. + </devdoc> + </member> + <member name="T:Moq.MockBehavior"> + <summary> + Options to customize the behavior of the mock. + </summary> + </member> + <member name="F:Moq.MockBehavior.Strict"> + <summary> + Causes the mock to always throw + an exception for invocations that don't have a + corresponding setup. + </summary> + </member> + <member name="F:Moq.MockBehavior.Loose"> + <summary> + Will never throw exceptions, returning default + values when necessary (null for reference types, + zero for value types or empty enumerables and arrays). + </summary> + </member> + <member name="F:Moq.MockBehavior.Default"> + <summary> + Default mock behavior, which equals <see cref="F:Moq.MockBehavior.Loose"/>. + </summary> + </member> + <member name="T:Moq.MockDefaultValueProvider"> + <summary> + A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value + for non-mockeable types, and mocks for all other types (interfaces and + non-sealed classes) that can be mocked. + </summary> + </member> + <member name="T:Moq.MockException"> + <summary> + Exception thrown by mocks when setups are not matched, + the mock is not properly setup, etc. + </summary> + <remarks> + A distinct exception type is provided so that exceptions + thrown by the mock can be differentiated in tests that + expect other exceptions to be thrown (i.e. ArgumentException). + <para> + Richer exception hierarchy/types are not provided as + tests typically should <b>not</b> catch or expect exceptions + from the mocks. These are typically the result of changes + in the tested class or its collaborators implementation, and + result in fixes in the mock setup so that they dissapear and + allow the test to pass. + </para> + </remarks> + </member> + <member name="P:Moq.MockException.IsVerificationError"> + <summary> + Indicates whether this exception is a verification fault raised by Verify() + </summary> + </member> + <member name="T:Moq.MockException.ExceptionReason"> + <summary> + Made internal as it's of no use for + consumers, but it's important for + our own tests. + </summary> + </member> + <member name="T:Moq.MockVerificationException"> + <devdoc> + Used by the mock factory to accumulate verification + failures. + </devdoc> + </member> + <member name="T:Moq.MockSequence"> + <summary> + Helper class to setup a full trace between many mocks + </summary> + </member> + <member name="M:Moq.MockSequence.#ctor"> + <summary> + Initialize a trace setup + </summary> + </member> + <member name="P:Moq.MockSequence.Cyclic"> + <summary> + Allow sequence to be repeated + </summary> + </member> + <member name="T:Moq.MockSequenceHelper"> + <summary> + define nice api + </summary> + </member> + <member name="M:Moq.MockSequenceHelper.InSequence``1(Moq.Mock{``0},Moq.MockSequence)"> + <summary> + Perform an expectation in the trace. + </summary> + </member> + <member name="T:Moq.MockLegacyExtensions"> + <summary> + Provides legacy API members as extensions so that + existing code continues to compile, but new code + doesn't see then. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)"> + <summary> + Obsolete. + </summary> + </member> + <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1,System.String)"> + <summary> + Obsolete. + </summary> + </member> + <member name="T:Moq.ObsoleteMockExtensions"> + <summary> + Provides additional methods on mocks. + </summary> + <devdoc> + Provided as extension methods as they confuse the compiler + with the overloads taking Action. + </devdoc> + </member> + <member name="M:Moq.ObsoleteMockExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Specifies a setup on the mocked type for a call to + to a property setter, regardless of its value. + </summary> + <remarks> + If more than one setup is set for the same property setter, + the latest one wins and is the one that will be executed. + </remarks> + <typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam> + <typeparam name="T">Type of the mock.</typeparam> + <param name="mock">The target mock for the setup.</param> + <param name="expression">Lambda expression that specifies the property setter.</param> + <example group="setups"> + <code> + mock.SetupSet(x => x.Suspended); + </code> + </example> + <devdoc> + This method is not legacy, but must be on an extension method to avoid + confusing the compiler with the new Action syntax. + </devdoc> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Verifies that a property has been set on the mock, regarless of its value. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <param name="expression">Expression to verify.</param> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)"> + <summary> + Verifies that a property has been set on the mock, specifying a failure + error message. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <param name="expression">Expression to verify.</param> + <param name="failMessage">Message to show if verification fails.</param> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times)"> + <summary> + Verifies that a property has been set on the mock, regardless + of the value but only the specified number of times. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="expression">Expression to verify.</param> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="M:Moq.ObsoleteMockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times,System.String)"> + <summary> + Verifies that a property has been set on the mock, regardless + of the value but only the specified number of times, and specifying a failure + error message. + </summary> + <example group="verification"> + This example assumes that the mock has been used, + and later we want to verify that a given invocation + with specific parameters was performed: + <code> + var mock = new Mock<IWarehouse>(); + // exercise mock + //... + // Will throw if the test code didn't set the IsClosed property. + mock.VerifySet(warehouse => warehouse.IsClosed); + </code> + </example> + <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="mock">The mock instance.</param> + <typeparam name="T">Mocked type.</typeparam> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="failMessage">Message to show if verification fails.</param> + <param name="expression">Expression to verify.</param> + <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can + be inferred from the expression's return type.</typeparam> + </member> + <member name="T:Moq.Protected.IProtectedMock`1"> + <summary> + Allows setups to be specified for protected members by using their + name as a string, rather than strong-typing them which is not possible + due to their visibility. + </summary> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Setup(System.String,System.Object[])"> + <summary> + Specifies a setup for a void method invocation with the given + <paramref name="voidMethodName"/>, optionally specifying arguments for the method call. + </summary> + <param name="voidMethodName">The name of the void method to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Setup``1(System.String,System.Object[])"> + <summary> + Specifies a setup for an invocation on a property or a non void method with the given + <paramref name="methodOrPropertyName"/>, optionally specifying arguments for the method call. + </summary> + <param name="methodOrPropertyName">The name of the method or property to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <typeparam name="TResult">The return type of the method or property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.SetupGet``1(System.String)"> + <summary> + Specifies a setup for an invocation on a property getter with the given + <paramref name="propertyName"/>. + </summary> + <param name="propertyName">The name of the property.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.SetupSet``1(System.String,System.Object)"> + <summary> + Specifies a setup for an invocation on a property setter with the given + <paramref name="propertyName"/>. + </summary> + <param name="propertyName">The name of the property.</param> + <param name="value">The property value. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Verify(System.String,Moq.Times,System.Object[])"> + <summary> + Specifies a verify for a void method with the given <paramref name="methodName"/>, + optionally specifying arguments for the method call. Use in conjuntion with the default + <see cref="F:Moq.MockBehavior.Loose"/>. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="methodName">The name of the void method to be verified.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.Verify``1(System.String,Moq.Times,System.Object[])"> + <summary> + Specifies a verify for an invocation on a property or a non void method with the given + <paramref name="methodName"/>, optionally specifying arguments for the method call. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="methodName">The name of the method or property to be invoked.</param> + <param name="args">The optional arguments for the invocation. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <typeparam name="TResult">The type of return value from the expression.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.VerifyGet``1(System.String,Moq.Times)"> + <summary> + Specifies a verify for an invocation on a property getter with the given + <paramref name="propertyName"/>. + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + </summary> + <param name="propertyName">The name of the property.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <typeparam name="TProperty">The type of the property.</typeparam> + </member> + <member name="M:Moq.Protected.IProtectedMock`1.VerifySet``1(System.String,Moq.Times,System.Object)"> + <summary> + Specifies a setup for an invocation on a property setter with the given + <paramref name="propertyName"/>. + </summary> + <exception cref="T:Moq.MockException">The invocation was not call the times specified by + <paramref name="times"/>.</exception> + <param name="propertyName">The name of the property.</param> + <param name="times">The number of times a method is allowed to be called.</param> + <param name="value">The property value.</param> + <typeparam name="TProperty">The type of the property. If argument matchers are used, + remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</typeparam> + </member> + <member name="T:Moq.Protected.ItExpr"> + <summary> + Allows the specification of a matching condition for an + argument in a protected member setup, rather than a specific + argument value. "ItExpr" refers to the argument being matched. + </summary> + <remarks> + <para>Use this variant of argument matching instead of + <see cref="T:Moq.It"/> for protected setups.</para> + This class allows the setup to match a method invocation + with an arbitrary value, with a value in a specified range, or + even one that matches a given predicate, or null. + </remarks> + </member> + <member name="M:Moq.Protected.ItExpr.IsNull``1"> + <summary> + Matches a null value of the given <typeparamref name="TValue"/> type. + </summary> + <remarks> + Required for protected mocks as the null value cannot be used + directly as it prevents proper method overload selection. + </remarks> + <example> + <code> + // Throws an exception for a call to Remove with a null string value. + mock.Protected() + .Setup("Remove", ItExpr.IsNull<string>()) + .Throws(new InvalidOperationException()); + </code> + </example> + <typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.Protected.ItExpr.IsAny``1"> + <summary> + Matches any value of the given <typeparamref name="TValue"/> type. + </summary> + <remarks> + Typically used when the actual argument value for a method + call is not relevant. + </remarks> + <example> + <code> + // Throws an exception for a call to Remove with any string value. + mock.Protected() + .Setup("Remove", ItExpr.IsAny<string>()) + .Throws(new InvalidOperationException()); + </code> + </example> + <typeparam name="TValue">Type of the value.</typeparam> + </member> + <member name="M:Moq.Protected.ItExpr.Is``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})"> + <summary> + Matches any value that satisfies the given predicate. + </summary> + <typeparam name="TValue">Type of the argument to check.</typeparam> + <param name="match">The predicate used to match the method argument.</param> + <remarks> + Allows the specification of a predicate to perform matching + of method call arguments. + </remarks> + <example> + This example shows how to return the value <c>1</c> whenever the argument to the + <c>Do</c> method is an even number. + <code> + mock.Protected() + .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) + .Returns(1); + </code> + This example shows how to throw an exception if the argument to the + method is a negative number: + <code> + mock.Protected() + .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) + .Throws(new ArgumentException()); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsInRange``1(``0,``0,Moq.Range)"> + <summary> + Matches any value that is in the range specified. + </summary> + <typeparam name="TValue">Type of the argument to check.</typeparam> + <param name="from">The lower bound of the range.</param> + <param name="to">The upper bound of the range.</param> + <param name="rangeKind">The kind of range. See <see cref="T:Moq.Range"/>.</param> + <example> + The following example shows how to expect a method call + with an integer argument within the 0..100 range. + <code> + mock.Protected() + .Setup("HasInventory", + ItExpr.IsAny<string>(), + ItExpr.IsInRange(0, 100, Range.Inclusive)) + .Returns(false); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsRegex(System.String)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary> + <param name="regex">The pattern to use to match the string argument value.</param> + <example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression: + <code> + mock.Protected() + .Setup("Check", ItExpr.IsRegex("[a-z]+")) + .Returns(1); + </code> + </example> + </member> + <member name="M:Moq.Protected.ItExpr.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)"> + <summary> + Matches a string argument if it matches the given regular expression pattern. + </summary> + <param name="regex">The pattern to use to match the string argument value.</param> + <param name="options">The options used to interpret the pattern.</param> + <example> + The following example shows how to expect a call to a method where the + string argument matches the given regular expression, in a case insensitive way: + <code> + mock.Protected() + .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) + .Returns(1); + </code> + </example> + </member> + <member name="T:Moq.Protected.ProtectedExtension"> + <summary> + Enables the <c>Protected()</c> method on <see cref="T:Moq.Mock`1"/>, + allowing setups to be set for protected members by using their + name as a string, rather than strong-typing them which is not possible + due to their visibility. + </summary> + </member> + <member name="M:Moq.Protected.ProtectedExtension.Protected``1(Moq.Mock{``0})"> + <summary> + Enable protected setups for the mock. + </summary> + <typeparam name="T">Mocked object type. Typically omitted as it can be inferred from the mock instance.</typeparam> + <param name="mock">The mock to set the protected setups on.</param> + </member> + <member name="T:ThisAssembly"> + <group name="overview" title="Overview" order="0" /> + <group name="setups" title="Specifying setups" order="1" /> + <group name="returns" title="Returning values from members" order="2" /> + <group name="verification" title="Verifying setups" order="3" /> + <group name="advanced" title="Advanced scenarios" order="99" /> + <group name="factory" title="Using MockFactory for consistency across mocks" order="4" /> + </member> + <member name="T:Moq.Properties.Resources"> + <summary> + A strongly-typed resource class, for looking up localized strings, etc. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ResourceManager"> + <summary> + Returns the cached ResourceManager instance used by this class. + </summary> + </member> + <member name="P:Moq.Properties.Resources.Culture"> + <summary> + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + </summary> + </member> + <member name="P:Moq.Properties.Resources.AlreadyInitialized"> + <summary> + Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ArgumentCannotBeEmpty"> + <summary> + Looks up a localized string similar to Value cannot be an empty string.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.AsMustBeInterface"> + <summary> + Looks up a localized string similar to Can only add interfaces to the mock.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.CantSetReturnValueForVoid"> + <summary> + Looks up a localized string similar to Can't set return value for void method {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorArgsForDelegate"> + <summary> + Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorArgsForInterface"> + <summary> + Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ConstructorNotFound"> + <summary> + Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.EventNofFound"> + <summary> + Looks up a localized string similar to Could not locate event for attach or detach method {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.FieldsNotSupported"> + <summary> + Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.InvalidMockClass"> + <summary> + Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . + </summary> + </member> + <member name="P:Moq.Properties.Resources.InvalidMockGetType"> + <summary> + Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. + Please cast the argument to one of the supported types: {1}. + Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqBinaryOperatorNotSupported"> + <summary> + Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqMethodNotSupported"> + <summary> + Looks up a localized string similar to LINQ method '{0}' not supported.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.LinqMethodNotVirtual"> + <summary> + Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MemberMissing"> + <summary> + Looks up a localized string similar to Member {0}.{1} does not exist.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MethodIsPublic"> + <summary> + Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: + mock.Setup(x => x.{1}()); + . + </summary> + </member> + <member name="P:Moq.Properties.Resources.MockExceptionMessage"> + <summary> + Looks up a localized string similar to {0} invocation failed with mock behavior {1}. + {2}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MoreThanNCalls"> + <summary> + Looks up a localized string similar to Expected only {0} calls to {1}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.MoreThanOneCall"> + <summary> + Looks up a localized string similar to Expected only one call to {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeast"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at least {2} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeastOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at least once, but was never performed: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMost"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at most {3} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMostOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock at most once, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenExclusive"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenInclusive"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsExactly"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock exactly {2} times, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsNever"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock should never have been performed, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoMatchingCallsOnce"> + <summary> + Looks up a localized string similar to {0} + Expected invocation on the mock once, but was {4} times: {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.NoSetup"> + <summary> + Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ObjectInstanceNotMock"> + <summary> + Looks up a localized string similar to Object instance was not created by Moq.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.OutExpressionMustBeConstantValue"> + <summary> + Looks up a localized string similar to Out expression must evaluate to a constant value.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyGetNotFound"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not have a getter.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyMissing"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not exist.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyNotReadable"> + <summary> + Looks up a localized string similar to Property {0}.{1} is write-only.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertyNotWritable"> + <summary> + Looks up a localized string similar to Property {0}.{1} is read-only.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.PropertySetNotFound"> + <summary> + Looks up a localized string similar to Property {0}.{1} does not have a setter.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.RaisedUnassociatedEvent"> + <summary> + Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.RefExpressionMustBeConstantValue"> + <summary> + Looks up a localized string similar to Ref expression must evaluate to a constant value.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.ReturnValueRequired"> + <summary> + Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupLambda"> + <summary> + Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNever"> + <summary> + Looks up a localized string similar to Invocation {0} should not have been made.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotMethod"> + <summary> + Looks up a localized string similar to Expression is not a method invocation: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotProperty"> + <summary> + Looks up a localized string similar to Expression is not a property access: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupNotSetter"> + <summary> + Looks up a localized string similar to Expression is not a property setter invocation.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupOnNonMemberMethod"> + <summary> + Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.SetupOnNonOverridableMember"> + <summary> + Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.TypeNotImplementInterface"> + <summary> + Looks up a localized string similar to Type {0} does not implement required interface {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.TypeNotInheritFromType"> + <summary> + Looks up a localized string similar to Type {0} does not from required type {1}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnexpectedPublicProperty"> + <summary> + Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: + mock.Setup(x => x.{1}).Returns(value); + mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one + mock.SetupSet(x => x.{1}).Callback(callbackDelegate); + . + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedExpression"> + <summary> + Looks up a localized string similar to Unsupported expression: {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedIntermediateExpression"> + <summary> + Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedIntermediateType"> + <summary> + Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedMatcherParamsForSetter"> + <summary> + Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedMember"> + <summary> + Looks up a localized string similar to Member {0} is not supported for protected mocking.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.UnsupportedNonStaticMatcherForSetter"> + <summary> + Looks up a localized string similar to Setter expression can only use static custom matchers.. + </summary> + </member> + <member name="P:Moq.Properties.Resources.VerficationFailed"> + <summary> + Looks up a localized string similar to The following setups were not matched: + {0}. + </summary> + </member> + <member name="P:Moq.Properties.Resources.VerifyOnNonVirtualMember"> + <summary> + Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. + </summary> + </member> + <member name="M:Moq.Proxy.IProxyFactory.GetDelegateProxyInterface(System.Type,System.Reflection.MethodInfo@)"> + <summary> + Gets an autogenerated interface with a method on it that matches the signature of the specified + <paramref name="delegateType"/>. + </summary> + <remarks> + Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. + This is how we support delegate mocking. The factory caches such interfaces and reuses them + for repeated requests for the same delegate type. + </remarks> + <param name="delegateType">The delegate type for which an interface is required.</param> + <param name="delegateInterfaceMethod">The method on the autogenerated interface.</param> + </member> + <member name="M:Moq.Proxy.CastleProxyFactory.CreateProxy(System.Type,Moq.Proxy.ICallInterceptor,System.Type[],System.Object[])"> + <inheritdoc /> + </member> + <member name="M:Moq.Proxy.CastleProxyFactory.GetDelegateProxyInterface(System.Type,System.Reflection.MethodInfo@)"> + <inheritdoc /> + </member> + <member name="T:Moq.Range"> + <summary> + Kind of range to use in a filter specified through + <see cref="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)"/>. + </summary> + </member> + <member name="F:Moq.Range.Inclusive"> + <summary> + The range includes the <c>to</c> and + <c>from</c> values. + </summary> + </member> + <member name="F:Moq.Range.Exclusive"> + <summary> + The range does not include the <c>to</c> and + <c>from</c> values. + </summary> + </member> + <member name="T:Moq.SequenceExtensions"> + <summary> + Helper for sequencing return values in the same method. + </summary> + </member> + <member name="M:Moq.SequenceExtensions.SetupSequence``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Return a sequence of values, once per call. + </summary> + </member> + <member name="T:Moq.Times"> + <summary> + Defines the number of invocations allowed by a mocked method. + </summary> + </member> + <member name="M:Moq.Times.AtLeast(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked <paramref name="callCount"/> times as minimum. + </summary><param name="callCount">The minimun number of times.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtLeastOnce"> + <summary> + Specifies that a mocked method should be invoked one time as minimum. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtMost(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked <paramref name="callCount"/> time as maximun. + </summary><param name="callCount">The maximun number of times.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.AtMostOnce"> + <summary> + Specifies that a mocked method should be invoked one time as maximun. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Between(System.Int32,System.Int32,Moq.Range)"> + <summary> + Specifies that a mocked method should be invoked between <paramref name="callCountFrom"/> and + <paramref name="callCountTo"/> times. + </summary><param name="callCountFrom">The minimun number of times.</param><param name="callCountTo">The maximun number of times.</param><param name="rangeKind"> + The kind of range. See <see cref="T:Moq.Range"/>. + </param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Exactly(System.Int32)"> + <summary> + Specifies that a mocked method should be invoked exactly <paramref name="callCount"/> times. + </summary><param name="callCount">The times that a method or property can be called.</param><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Never"> + <summary> + Specifies that a mocked method should not be invoked. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Once"> + <summary> + Specifies that a mocked method should be invoked exactly one time. + </summary><returns>An object defining the allowed number of invocations.</returns> + </member> + <member name="M:Moq.Times.Equals(System.Object)"> + <summary> + Determines whether the specified <see cref="T:System.Object"/> is equal to this instance. + </summary><param name="obj"> + The <see cref="T:System.Object"/> to compare with this instance. + </param><returns> + <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>. + </returns> + </member> + <member name="M:Moq.Times.GetHashCode"> + <summary> + Returns a hash code for this instance. + </summary><returns> + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + </returns> + </member> + <member name="M:Moq.Times.op_Equality(Moq.Times,Moq.Times)"> + <summary> + Determines whether two specified <see cref="T:Moq.Times"/> objects have the same value. + </summary><param name="left"> + The first <see cref="T:Moq.Times"/>. + </param><param name="right"> + The second <see cref="T:Moq.Times"/>. + </param><returns> + <c>true</c> if the value of left is the same as the value of right; otherwise, <c>false</c>. + </returns> + </member> + <member name="M:Moq.Times.op_Inequality(Moq.Times,Moq.Times)"> + <summary> + Determines whether two specified <see cref="T:Moq.Times"/> objects have different values. + </summary><param name="left"> + The first <see cref="T:Moq.Times"/>. + </param><param name="right"> + The second <see cref="T:Moq.Times"/>. + </param><returns> + <c>true</c> if the value of left is different from the value of right; otherwise, <c>false</c>. + </returns> + </member> + </members> +</doc>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/NUnit.2.6.3/NUnit.2.6.3.nuspec Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,27 @@ +<?xml version="1.0"?> +<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd"> + <metadata> + <id>NUnit</id> + <version>2.6.3</version> + <title>NUnit</title> + <authors>Charlie Poole</authors> + <owners>Charlie Poole</owners> + <licenseUrl>http://nunit.org/nuget/license.html</licenseUrl> + <projectUrl>http://nunit.org/</projectUrl> + <iconUrl>http://nunit.org/nuget/nunit_32x32.png</iconUrl> + <requireLicenseAcceptance>false</requireLicenseAcceptance> + <description>NUnit features a fluent assert syntax, parameterized, generic and theory tests and is user-extensible. A number of runners, both from the NUnit project and by third parties, are able to execute NUnit tests. + +Version 2.6 is the seventh major release of this well-known and well-tested programming tool. + +This package includes only the framework assembly. You will need to install the NUnit.Runners package unless you are using a third-party runner.</description> + <summary>NUnit is a unit-testing framework for all .Net languages with a strong TDD focus.</summary> + <releaseNotes>Version 2.6 is the seventh major release of NUnit. + +Unlike earlier versions, this package includes only the framework assembly. You will need to install the NUnit.Runners package unless you are using a third-party runner. + +The nunit.mocks assembly is now provided by the NUnit.Mocks package. The pnunit.framework assembly is provided by the pNUnit package.</releaseNotes> + <language>en-US</language> + <tags>nunit test testing tdd framework fluent assert theory plugin addin</tags> + </metadata> +</package> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/NUnit.2.6.3/lib/nunit.framework.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,10960 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>nunit.framework</name> + </assembly> + <members> + <member name="T:NUnit.Framework.ActionTargets"> + <summary> + The different targets a test action attribute can be applied to + </summary> + </member> + <member name="F:NUnit.Framework.ActionTargets.Default"> + <summary> + Default target, which is determined by where the action attribute is attached + </summary> + </member> + <member name="F:NUnit.Framework.ActionTargets.Test"> + <summary> + Target a individual test case + </summary> + </member> + <member name="F:NUnit.Framework.ActionTargets.Suite"> + <summary> + Target a suite of test cases + </summary> + </member> + <member name="T:NUnit.Framework.TestDelegate"> + <summary> + Delegate used by tests that execute code and + capture any thrown exception. + </summary> + </member> + <member name="T:NUnit.Framework.Assert"> + <summary> + The Assert class contains a collection of static methods that + implement the most common assertions used in NUnit. + </summary> + </member> + <member name="M:NUnit.Framework.Assert.#ctor"> + <summary> + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + </summary> + </member> + <member name="M:NUnit.Framework.Assert.Equals(System.Object,System.Object)"> + <summary> + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.Assert.ReferenceEquals(System.Object,System.Object)"> + <summary> + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.Assert.Pass(System.String,System.Object[])"> + <summary> + Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Pass(System.String)"> + <summary> + Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param> + </member> + <member name="M:NUnit.Framework.Assert.Pass"> + <summary> + Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + </summary> + </member> + <member name="M:NUnit.Framework.Assert.Fail(System.String,System.Object[])"> + <summary> + Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message and arguments + that are passed in. This is used by the other Assert functions. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Fail(System.String)"> + <summary> + Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message that is + passed in. This is used by the other Assert functions. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param> + </member> + <member name="M:NUnit.Framework.Assert.Fail"> + <summary> + Throws an <see cref="T:NUnit.Framework.AssertionException"/>. + This is used by the other Assert functions. + </summary> + </member> + <member name="M:NUnit.Framework.Assert.Ignore(System.String,System.Object[])"> + <summary> + Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message and arguments + that are passed in. This causes the test to be reported as ignored. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Ignore(System.String)"> + <summary> + Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message that is + passed in. This causes the test to be reported as ignored. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param> + </member> + <member name="M:NUnit.Framework.Assert.Ignore"> + <summary> + Throws an <see cref="T:NUnit.Framework.IgnoreException"/>. + This causes the test to be reported as ignored. + </summary> + </member> + <member name="M:NUnit.Framework.Assert.Inconclusive(System.String,System.Object[])"> + <summary> + Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message and arguments + that are passed in. This causes the test to be reported as inconclusive. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Inconclusive(System.String)"> + <summary> + Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message that is + passed in. This causes the test to be reported as inconclusive. + </summary> + <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param> + </member> + <member name="M:NUnit.Framework.Assert.Inconclusive"> + <summary> + Throws an <see cref="T:NUnit.Framework.InconclusiveException"/>. + This causes the test to be reported as Inconclusive. + </summary> + </member> + <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + </member> + <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint expression to be applied</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display if the condition is false</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display if the condition is false</param> + </member> + <member name="M:NUnit.Framework.Assert.That(System.Boolean)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + </member> + <member name="M:NUnit.Framework.Assert.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + <param name="expr">A Constraint expression to be applied</param> + </member> + <member name="M:NUnit.Framework.Assert.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + <param name="expr">A Constraint expression to be applied</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + <param name="expr">A Constraint expression to be applied</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + </member> + <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + </summary> + <param name="code">A TestDelegate to be executed</param> + <param name="constraint">A ThrowsConstraint used in the test</param> + </member> + <member name="M:NUnit.Framework.Assert.ByVal(System.Object,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + Used as a synonym for That in rare cases where a private setter + causes a Visual Basic compilation error. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + </member> + <member name="M:NUnit.Framework.Assert.ByVal(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + Used as a synonym for That in rare cases where a private setter + causes a Visual Basic compilation error. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.ByVal(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + Used as a synonym for That in rare cases where a private setter + causes a Visual Basic compilation error. + </summary> + <remarks> + This method is provided for use by VB developers needing to test + the value of properties with private setters. + </remarks> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint expression to be applied</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String,System.Object[])"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <param name="expression">A constraint to be satisfied by the exception</param> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String)"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <param name="expression">A constraint to be satisfied by the exception</param> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate)"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <param name="expression">A constraint to be satisfied by the exception</param> + <param name="code">A TestDelegate</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <param name="expectedExceptionType">The exception Type expected</param> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String)"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <param name="expectedExceptionType">The exception Type expected</param> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate)"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <param name="expectedExceptionType">The exception Type expected</param> + <param name="code">A TestDelegate</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String,System.Object[])"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <typeparam name="T">Type of the expected exception</typeparam> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String)"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <typeparam name="T">Type of the expected exception</typeparam> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate)"> + <summary> + Verifies that a delegate throws a particular exception when called. + </summary> + <typeparam name="T">Type of the expected exception</typeparam> + <param name="code">A TestDelegate</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String,System.Object[])"> + <summary> + Verifies that a delegate throws an exception when called + and returns it. + </summary> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String)"> + <summary> + Verifies that a delegate throws an exception when called + and returns it. + </summary> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate)"> + <summary> + Verifies that a delegate throws an exception when called + and returns it. + </summary> + <param name="code">A TestDelegate</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])"> + <summary> + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + </summary> + <param name="expectedExceptionType">The expected Exception Type</param> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String)"> + <summary> + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + </summary> + <param name="expectedExceptionType">The expected Exception Type</param> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate)"> + <summary> + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + </summary> + <param name="expectedExceptionType">The expected Exception Type</param> + <param name="code">A TestDelegate</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String,System.Object[])"> + <summary> + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + </summary> + <typeparam name="T">The expected Exception Type</typeparam> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String)"> + <summary> + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + </summary> + <typeparam name="T">The expected Exception Type</typeparam> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate)"> + <summary> + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + </summary> + <typeparam name="T">The expected Exception Type</typeparam> + <param name="code">A TestDelegate</param> + </member> + <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String,System.Object[])"> + <summary> + Verifies that a delegate does not throw an exception + </summary> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String)"> + <summary> + Verifies that a delegate does not throw an exception. + </summary> + <param name="code">A TestDelegate</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate)"> + <summary> + Verifies that a delegate does not throw an exception. + </summary> + <param name="code">A TestDelegate</param> + </member> + <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String,System.Object[])"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.True(System.Boolean)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + </member> + <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String,System.Object[])"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + </member> + <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String,System.Object[])"> + <summary> + Asserts that a condition is false. If the condition is true the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String)"> + <summary> + Asserts that a condition is false. If the condition is true the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.False(System.Boolean)"> + <summary> + Asserts that a condition is false. If the condition is true the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + </member> + <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String,System.Object[])"> + <summary> + Asserts that a condition is false. If the condition is true the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String)"> + <summary> + Asserts that a condition is false. If the condition is true the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean)"> + <summary> + Asserts that a condition is false. If the condition is true the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. + </summary> + <param name="condition">The evaluated condition</param> + </member> + <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String,System.Object[])"> + <summary> + Verifies that the object that is passed in is not equal to <code>null</code> + If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String)"> + <summary> + Verifies that the object that is passed in is not equal to <code>null</code> + If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.NotNull(System.Object)"> + <summary> + Verifies that the object that is passed in is not equal to <code>null</code> + If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String,System.Object[])"> + <summary> + Verifies that the object that is passed in is not equal to <code>null</code> + If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String)"> + <summary> + Verifies that the object that is passed in is not equal to <code>null</code> + If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object)"> + <summary> + Verifies that the object that is passed in is not equal to <code>null</code> + If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String,System.Object[])"> + <summary> + Verifies that the object that is passed in is equal to <code>null</code> + If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String)"> + <summary> + Verifies that the object that is passed in is equal to <code>null</code> + If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Null(System.Object)"> + <summary> + Verifies that the object that is passed in is equal to <code>null</code> + If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String,System.Object[])"> + <summary> + Verifies that the object that is passed in is equal to <code>null</code> + If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String)"> + <summary> + Verifies that the object that is passed in is equal to <code>null</code> + If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNull(System.Object)"> + <summary> + Verifies that the object that is passed in is equal to <code>null</code> + If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="anObject">The object that is to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String,System.Object[])"> + <summary> + Verifies that two ints are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String)"> + <summary> + Verifies that two ints are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32)"> + <summary> + Verifies that two ints are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String,System.Object[])"> + <summary> + Verifies that two longs are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String)"> + <summary> + Verifies that two longs are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64)"> + <summary> + Verifies that two longs are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String,System.Object[])"> + <summary> + Verifies that two unsigned ints are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String)"> + <summary> + Verifies that two unsigned ints are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32)"> + <summary> + Verifies that two unsigned ints are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String,System.Object[])"> + <summary> + Verifies that two unsigned longs are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String)"> + <summary> + Verifies that two unsigned longs are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64)"> + <summary> + Verifies that two unsigned longs are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String,System.Object[])"> + <summary> + Verifies that two decimals are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String)"> + <summary> + Verifies that two decimals are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal)"> + <summary> + Verifies that two decimals are equal. If they are not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])"> + <summary> + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is + thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="delta">The maximum acceptable difference between the + the expected and the actual</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String)"> + <summary> + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is + thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="delta">The maximum acceptable difference between the + the expected and the actual</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double)"> + <summary> + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is + thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="delta">The maximum acceptable difference between the + the expected and the actual</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String,System.Object[])"> + <summary> + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is + thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="delta">The maximum acceptable difference between the + the expected and the actual</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String)"> + <summary> + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is + thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="delta">The maximum acceptable difference between the + the expected and the actual</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double)"> + <summary> + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is + thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="delta">The maximum acceptable difference between the + the expected and the actual</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String,System.Object[])"> + <summary> + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The value that is expected</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String)"> + <summary> + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The value that is expected</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object)"> + <summary> + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The value that is expected</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String,System.Object[])"> + <summary> + Verifies that two ints are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String)"> + <summary> + Verifies that two ints are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32)"> + <summary> + Verifies that two ints are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String,System.Object[])"> + <summary> + Verifies that two longs are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String)"> + <summary> + Verifies that two longs are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64)"> + <summary> + Verifies that two longs are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String,System.Object[])"> + <summary> + Verifies that two unsigned ints are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String)"> + <summary> + Verifies that two unsigned ints are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32)"> + <summary> + Verifies that two unsigned ints are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String,System.Object[])"> + <summary> + Verifies that two unsigned longs are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String)"> + <summary> + Verifies that two unsigned longs are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64)"> + <summary> + Verifies that two unsigned longs are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String,System.Object[])"> + <summary> + Verifies that two decimals are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String)"> + <summary> + Verifies that two decimals are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal)"> + <summary> + Verifies that two decimals are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String,System.Object[])"> + <summary> + Verifies that two floats are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String)"> + <summary> + Verifies that two floats are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single)"> + <summary> + Verifies that two floats are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String,System.Object[])"> + <summary> + Verifies that two doubles are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String)"> + <summary> + Verifies that two doubles are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double)"> + <summary> + Verifies that two doubles are not equal. If they are equal, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String,System.Object[])"> + <summary> + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The value that is expected</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String)"> + <summary> + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The value that is expected</param> + <param name="actual">The actual value</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object)"> + <summary> + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The value that is expected</param> + <param name="actual">The actual value</param> + </member> + <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String,System.Object[])"> + <summary> + Asserts that two objects refer to the same object. If they + are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The actual object</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String)"> + <summary> + Asserts that two objects refer to the same object. If they + are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The actual object</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object)"> + <summary> + Asserts that two objects refer to the same object. If they + are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The actual object</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String,System.Object[])"> + <summary> + Asserts that two objects do not refer to the same object. If they + are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The actual object</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String)"> + <summary> + Asserts that two objects do not refer to the same object. If they + are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The actual object</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object)"> + <summary> + Asserts that two objects do not refer to the same object. If they + are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The actual object</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String,System.Object[])"> + <summary> + Verifies that the double that is passed in is an <code>NaN</code> value. + If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="aDouble">The value that is to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String)"> + <summary> + Verifies that the double that is passed in is an <code>NaN</code> value. + If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="aDouble">The value that is to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNaN(System.Double)"> + <summary> + Verifies that the double that is passed in is an <code>NaN</code> value. + If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="aDouble">The value that is to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String,System.Object[])"> + <summary> + Verifies that the double that is passed in is an <code>NaN</code> value. + If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="aDouble">The value that is to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String)"> + <summary> + Verifies that the double that is passed in is an <code>NaN</code> value. + If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="aDouble">The value that is to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double})"> + <summary> + Verifies that the double that is passed in is an <code>NaN</code> value. + If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/> + is thrown. + </summary> + <param name="aDouble">The value that is to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String,System.Object[])"> + <summary> + Assert that a string is empty - that is equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String)"> + <summary> + Assert that a string is empty - that is equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsEmpty(System.String)"> + <summary> + Assert that a string is empty - that is equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Assert that an array, list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing ICollection</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.IEnumerable,System.String)"> + <summary> + Assert that an array, list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing ICollection</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.IEnumerable)"> + <summary> + Assert that an array, list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing ICollection</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String,System.Object[])"> + <summary> + Assert that a string is not empty - that is not equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String)"> + <summary> + Assert that a string is not empty - that is not equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String)"> + <summary> + Assert that a string is not empty - that is not equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Assert that an array, list or other collection is not empty + </summary> + <param name="collection">An array, list or other collection implementing ICollection</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.IEnumerable,System.String)"> + <summary> + Assert that an array, list or other collection is not empty + </summary> + <param name="collection">An array, list or other collection implementing ICollection</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.IEnumerable)"> + <summary> + Assert that an array, list or other collection is not empty + </summary> + <param name="collection">An array, list or other collection implementing ICollection</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String,System.Object[])"> + <summary> + Assert that a string is either null or equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String)"> + <summary> + Assert that a string is either null or equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String)"> + <summary> + Assert that a string is either null or equal to string.Empty + </summary> + <param name="aString">The string to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String,System.Object[])"> + <summary> + Assert that a string is not null or empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String)"> + <summary> + Assert that a string is not null or empty + </summary> + <param name="aString">The string to be tested</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String)"> + <summary> + Assert that a string is not null or empty + </summary> + <param name="aString">The string to be tested</param> + </member> + <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object may be assigned a value of a given Type. + </summary> + <param name="expected">The expected Type.</param> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String)"> + <summary> + Asserts that an object may be assigned a value of a given Type. + </summary> + <param name="expected">The expected Type.</param> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object)"> + <summary> + Asserts that an object may be assigned a value of a given Type. + </summary> + <param name="expected">The expected Type.</param> + <param name="actual">The object under examination</param> + </member> + <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object may be assigned a value of a given Type. + </summary> + <typeparam name="T">The expected Type.</typeparam> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String)"> + <summary> + Asserts that an object may be assigned a value of a given Type. + </summary> + <typeparam name="T">The expected Type.</typeparam> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object)"> + <summary> + Asserts that an object may be assigned a value of a given Type. + </summary> + <typeparam name="T">The expected Type.</typeparam> + <param name="actual">The object under examination</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object may not be assigned a value of a given Type. + </summary> + <param name="expected">The expected Type.</param> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String)"> + <summary> + Asserts that an object may not be assigned a value of a given Type. + </summary> + <param name="expected">The expected Type.</param> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object)"> + <summary> + Asserts that an object may not be assigned a value of a given Type. + </summary> + <param name="expected">The expected Type.</param> + <param name="actual">The object under examination</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object may not be assigned a value of a given Type. + </summary> + <typeparam name="T">The expected Type.</typeparam> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String)"> + <summary> + Asserts that an object may not be assigned a value of a given Type. + </summary> + <typeparam name="T">The expected Type.</typeparam> + <param name="actual">The object under examination</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object)"> + <summary> + Asserts that an object may not be assigned a value of a given Type. + </summary> + <typeparam name="T">The expected Type.</typeparam> + <param name="actual">The object under examination</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String)"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object)"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String)"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object)"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <typeparam name="T">The expected Type</typeparam> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String)"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <typeparam name="T">The expected Type</typeparam> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object)"> + <summary> + Asserts that an object is an instance of a given type. + </summary> + <typeparam name="T">The expected Type</typeparam> + <param name="actual">The object being examined</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String)"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object)"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String)"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object)"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <param name="expected">The expected Type</param> + <param name="actual">The object being examined</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String,System.Object[])"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <typeparam name="T">The expected Type</typeparam> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String)"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <typeparam name="T">The expected Type</typeparam> + <param name="actual">The object being examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object)"> + <summary> + Asserts that an object is not an instance of a given type. + </summary> + <typeparam name="T">The expected Type</typeparam> + <param name="actual">The object being examined</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable)"> + <summary> + Verifies that the first value is greater than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable)"> + <summary> + Verifies that the first value is less than the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable)"> + <summary> + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be greater</param> + <param name="arg2">The second value, expected to be less</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable)"> + <summary> + Verifies that the first value is less than or equal to the second + value. If it is not, then an + <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="arg1">The first value, expected to be less</param> + <param name="arg2">The second value, expected to be greater</param> + </member> + <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String,System.Object[])"> + <summary> + Asserts that an object is contained in a list. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The list to be examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String)"> + <summary> + Asserts that an object is contained in a list. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The list to be examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection)"> + <summary> + Asserts that an object is contained in a list. + </summary> + <param name="expected">The expected object</param> + <param name="actual">The list to be examined</param> + </member> + <member name="M:NUnit.Framework.Assert.AssertDoublesAreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])"> + <summary> + Helper for Assert.AreEqual(double expected, double actual, ...) + allowing code generation to work consistently. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="delta">The maximum acceptable difference between the + the expected and the actual</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Array of objects to be used in formatting the message</param> + </member> + <member name="P:NUnit.Framework.Assert.Counter"> + <summary> + Gets the number of assertions executed so far and + resets the counter to zero. + </summary> + </member> + <member name="T:NUnit.Framework.AssertionHelper"> + <summary> + AssertionHelper is an optional base class for user tests, + allowing the use of shorter names for constraints and + asserts and avoiding conflict with the definition of + <see cref="T:NUnit.Framework.Is"/>, from which it inherits much of its + behavior, in certain mock object frameworks. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ConstraintFactory"> + <summary> + Helper class with properties and methods that supply + a number of constraints used in Asserts. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Exactly(System.Int32)"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding only if a specified number of them succeed. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Property(System.String)"> + <summary> + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute(System.Type)"> + <summary> + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute``1"> + <summary> + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EqualTo(System.Object)"> + <summary> + Returns a constraint that tests two items for equality + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SameAs(System.Object)"> + <summary> + Returns a constraint that tests that two references are the same object + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThan(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThanOrEqualTo(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtLeast(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThan(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThanOrEqualTo(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtMost(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf(System.Type)"> + <summary> + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf``1"> + <summary> + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf``1"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType``1"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom``1"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo``1"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EquivalentTo(System.Collections.IEnumerable)"> + <summary> + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubsetOf(System.Collections.IEnumerable)"> + <summary> + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Member(System.Object)"> + <summary> + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.Object)"> + <summary> + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.String)"> + <summary> + Returns a new ContainsConstraint. This constraint + will, in turn, make use of the appropriate second-level + constraint, depending on the type of the actual argument. + This overload is only used if the item sought is a string, + since any other type implies that we are looking for a + collection member. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringContaining(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.ContainsSubstring(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotContain(System.String)"> + <summary> + Returns a constraint that fails if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StartsWith(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringStarting(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotStartWith(System.String)"> + <summary> + Returns a constraint that fails if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EndsWith(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringEnding(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotEndWith(System.String)"> + <summary> + Returns a constraint that fails if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Matches(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value matches the regular expression supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringMatching(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value matches the regular expression supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotMatch(System.String)"> + <summary> + Returns a constraint that fails if the actual + value matches the pattern supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePath(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubPath(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePathOrUnder(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InRange``1(``0,``0)"> + <summary> + Returns a constraint that tests whether the actual value falls + within a specified range. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Not"> + <summary> + Returns a ConstraintExpression that negates any + following constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.No"> + <summary> + Returns a ConstraintExpression that negates any + following constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.All"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Some"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.None"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Length"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Count"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Message"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.InnerException"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Null"> + <summary> + Returns a constraint that tests for null + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.True"> + <summary> + Returns a constraint that tests for True + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.False"> + <summary> + Returns a constraint that tests for False + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Positive"> + <summary> + Returns a constraint that tests for a positive value + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Negative"> + <summary> + Returns a constraint that tests for a negative value + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.NaN"> + <summary> + Returns a constraint that tests for NaN + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Empty"> + <summary> + Returns a constraint that tests for empty + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Unique"> + <summary> + Returns a constraint that tests whether a collection + contains all unique items. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.BinarySerializable"> + <summary> + Returns a constraint that tests whether an object graph is serializable in binary format. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.XmlSerializable"> + <summary> + Returns a constraint that tests whether an object graph is serializable in xml format. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Ordered"> + <summary> + Returns a constraint that tests whether a collection is ordered + </summary> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to Assert.That. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to Assert.That. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message to be displayed in case of failure</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to Assert.That. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message to be displayed in case of failure</param> + <param name="args">Arguments to use in formatting the message</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String,System.Object[])"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to + <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display if the condition is false</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to + <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String)"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display if the condition is false</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to <see cref="M:NUnit.Framework.Assert.That(System.Boolean)"/>. + </summary> + <param name="condition">The evaluated condition</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="expr">A Constraint expression to be applied</param> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="expr">A Constraint expression to be applied</param> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + <param name="expr">A Constraint expression to be applied</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + </summary> + <param name="actual">The actual value to test</param> + <param name="expression">A Constraint to be applied</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + </summary> + <param name="code">A TestDelegate to be executed</param> + <param name="constraint">A ThrowsConstraint used in the test</param> + </member> + <member name="M:NUnit.Framework.AssertionHelper.Map(System.Collections.ICollection)"> + <summary> + Returns a ListMapper based on a collection. + </summary> + <param name="original">The original collection</param> + <returns></returns> + </member> + <member name="T:NUnit.Framework.Assume"> + <summary> + Provides static methods to express the assumptions + that must be met for a test to give a meaningful + result. If an assumption is not met, the test + should produce an inconclusive result. + </summary> + </member> + <member name="M:NUnit.Framework.Assume.Equals(System.Object,System.Object)"> + <summary> + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.Assume.ReferenceEquals(System.Object,System.Object)"> + <summary> + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expression">A Constraint expression to be applied</param> + <param name="actual">The actual value to test</param> + </member> + <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expression">A Constraint expression to be applied</param> + <param name="actual">The actual value to test</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expression">A Constraint expression to be applied</param> + <param name="actual">The actual value to test</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String,System.Object[])"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.InconclusiveException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display if the condition is false</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String)"> + <summary> + Asserts that a condition is true. If the condition is false the method throws + an <see cref="T:NUnit.Framework.InconclusiveException"/>. + </summary> + <param name="condition">The evaluated condition</param> + <param name="message">The message to display if the condition is false</param> + </member> + <member name="M:NUnit.Framework.Assume.That(System.Boolean)"> + <summary> + Asserts that a condition is true. If the condition is false the + method throws an <see cref="T:NUnit.Framework.InconclusiveException"/>. + </summary> + <param name="condition">The evaluated condition</param> + </member> + <member name="M:NUnit.Framework.Assume.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expr">A Constraint expression to be applied</param> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + </member> + <member name="M:NUnit.Framework.Assume.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expr">A Constraint expression to be applied</param> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assume.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="del">An ActualValueDelegate returning the value to be tested</param> + <param name="expr">A Constraint expression to be applied</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expression">A Constraint expression to be applied</param> + <param name="actual">The actual value to test</param> + </member> + <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expression">A Constraint expression to be applied</param> + <param name="actual">The actual value to test</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"> + <summary> + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + </summary> + <param name="expression">A Constraint expression to be applied</param> + <param name="actual">The actual value to test</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + </summary> + <param name="code">A TestDelegate to be executed</param> + <param name="constraint">A ThrowsConstraint used in the test</param> + </member> + <member name="M:NUnit.Framework.AsyncInvocationRegion.WaitForPendingOperationsToComplete(System.Object)"> + <summary> + Waits for pending asynchronous operations to complete, if appropriate, + and returns a proper result of the invocation by unwrapping task results + </summary> + <param name="invocationResult">The raw result of the method invocation</param> + <returns>The unwrapped result, if necessary</returns> + </member> + <member name="T:NUnit.Framework.CollectionAssert"> + <summary> + A set of Assert methods operationg on one or more collections + </summary> + </member> + <member name="M:NUnit.Framework.CollectionAssert.Equals(System.Object,System.Object)"> + <summary> + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.ReferenceEquals(System.Object,System.Object)"> + <summary> + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type)"> + <summary> + Asserts that all items contained in collection are of the type specified by expectedType. + </summary> + <param name="collection">IEnumerable containing objects to be considered</param> + <param name="expectedType">System.Type that all objects in collection must be instances of</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String)"> + <summary> + Asserts that all items contained in collection are of the type specified by expectedType. + </summary> + <param name="collection">IEnumerable containing objects to be considered</param> + <param name="expectedType">System.Type that all objects in collection must be instances of</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String,System.Object[])"> + <summary> + Asserts that all items contained in collection are of the type specified by expectedType. + </summary> + <param name="collection">IEnumerable containing objects to be considered</param> + <param name="expectedType">System.Type that all objects in collection must be instances of</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable)"> + <summary> + Asserts that all items contained in collection are not equal to null. + </summary> + <param name="collection">IEnumerable containing objects to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String)"> + <summary> + Asserts that all items contained in collection are not equal to null. + </summary> + <param name="collection">IEnumerable containing objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Asserts that all items contained in collection are not equal to null. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable)"> + <summary> + Ensures that every object contained in collection exists within the collection + once and only once. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String)"> + <summary> + Ensures that every object contained in collection exists within the collection + once and only once. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Ensures that every object contained in collection exists within the collection + once and only once. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)"> + <summary> + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)"> + <summary> + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)"> + <summary> + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)"> + <summary> + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])"> + <summary> + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)"> + <summary> + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)"> + <summary> + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)"> + <summary> + Asserts that expected and actual are not exactly equal. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)"> + <summary> + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)"> + <summary> + Asserts that expected and actual are not exactly equal. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)"> + <summary> + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Asserts that expected and actual are not exactly equal. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])"> + <summary> + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)"> + <summary> + Asserts that expected and actual are not equivalent. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)"> + <summary> + Asserts that expected and actual are not equivalent. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Asserts that expected and actual are not equivalent. + </summary> + <param name="expected">The first IEnumerable of objects to be considered</param> + <param name="actual">The second IEnumerable of objects to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object)"> + <summary> + Asserts that collection contains actual as an item. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="actual">Object to be found within collection</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String)"> + <summary> + Asserts that collection contains actual as an item. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="actual">Object to be found within collection</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String,System.Object[])"> + <summary> + Asserts that collection contains actual as an item. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="actual">Object to be found within collection</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object)"> + <summary> + Asserts that collection does not contain actual as an item. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="actual">Object that cannot exist within collection</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String)"> + <summary> + Asserts that collection does not contain actual as an item. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="actual">Object that cannot exist within collection</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String,System.Object[])"> + <summary> + Asserts that collection does not contain actual as an item. + </summary> + <param name="collection">IEnumerable of objects to be considered</param> + <param name="actual">Object that cannot exist within collection</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)"> + <summary> + Asserts that superset is not a subject of subset. + </summary> + <param name="subset">The IEnumerable superset to be considered</param> + <param name="superset">The IEnumerable subset to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)"> + <summary> + Asserts that superset is not a subject of subset. + </summary> + <param name="subset">The IEnumerable superset to be considered</param> + <param name="superset">The IEnumerable subset to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Asserts that superset is not a subject of subset. + </summary> + <param name="subset">The IEnumerable superset to be considered</param> + <param name="superset">The IEnumerable subset to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)"> + <summary> + Asserts that superset is a subset of subset. + </summary> + <param name="subset">The IEnumerable superset to be considered</param> + <param name="superset">The IEnumerable subset to be considered</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)"> + <summary> + Asserts that superset is a subset of subset. + </summary> + <param name="subset">The IEnumerable superset to be considered</param> + <param name="superset">The IEnumerable subset to be considered</param> + <param name="message">The message that will be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Asserts that superset is a subset of subset. + </summary> + <param name="subset">The IEnumerable superset to be considered</param> + <param name="superset">The IEnumerable subset to be considered</param> + <param name="message">The message that will be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Assert that an array, list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="message">The message to be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String)"> + <summary> + Assert that an array, list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="message">The message to be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable)"> + <summary> + Assert that an array,list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Assert that an array, list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="message">The message to be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String)"> + <summary> + Assert that an array, list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="message">The message to be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable)"> + <summary> + Assert that an array,list or other collection is empty + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String,System.Object[])"> + <summary> + Assert that an array, list or other collection is ordered + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="message">The message to be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String)"> + <summary> + Assert that an array, list or other collection is ordered + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="message">The message to be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable)"> + <summary> + Assert that an array, list or other collection is ordered + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])"> + <summary> + Assert that an array, list or other collection is ordered + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="comparer">A custom comparer to perform the comparisons</param> + <param name="message">The message to be displayed on failure</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String)"> + <summary> + Assert that an array, list or other collection is ordered + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="comparer">A custom comparer to perform the comparisons</param> + <param name="message">The message to be displayed on failure</param> + </member> + <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer)"> + <summary> + Assert that an array, list or other collection is ordered + </summary> + <param name="collection">An array, list or other collection implementing IEnumerable</param> + <param name="comparer">A custom comparer to perform the comparisons</param> + </member> + <member name="T:NUnit.Framework.Contains"> + <summary> + Helper class with properties and methods that supply + a number of constraints used in Asserts. + </summary> + </member> + <member name="M:NUnit.Framework.Contains.Item(System.Object)"> + <summary> + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + </summary> + </member> + <member name="M:NUnit.Framework.Contains.Substring(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="T:NUnit.Framework.DirectoryAssert"> + <summary> + Summary description for DirectoryAssert + </summary> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.Equals(System.Object,System.Object)"> + <summary> + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.ReferenceEquals(System.Object,System.Object)"> + <summary> + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.#ctor"> + <summary> + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + </summary> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])"> + <summary> + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory containing the value that is expected</param> + <param name="actual">A directory containing the actual value</param> + <param name="message">The message to display if directories are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)"> + <summary> + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory containing the value that is expected</param> + <param name="actual">A directory containing the actual value</param> + <param name="message">The message to display if directories are not equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)"> + <summary> + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory containing the value that is expected</param> + <param name="actual">A directory containing the actual value</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String,System.Object[])"> + <summary> + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory path string containing the value that is expected</param> + <param name="actual">A directory path string containing the actual value</param> + <param name="message">The message to display if directories are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String)"> + <summary> + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory path string containing the value that is expected</param> + <param name="actual">A directory path string containing the actual value</param> + <param name="message">The message to display if directories are not equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String)"> + <summary> + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory path string containing the value that is expected</param> + <param name="actual">A directory path string containing the actual value</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])"> + <summary> + Asserts that two directories are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory containing the value that is expected</param> + <param name="actual">A directory containing the actual value</param> + <param name="message">The message to display if directories are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)"> + <summary> + Asserts that two directories are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory containing the value that is expected</param> + <param name="actual">A directory containing the actual value</param> + <param name="message">The message to display if directories are not equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)"> + <summary> + Asserts that two directories are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory containing the value that is expected</param> + <param name="actual">A directory containing the actual value</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that two directories are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory path string containing the value that is expected</param> + <param name="actual">A directory path string containing the actual value</param> + <param name="message">The message to display if directories are equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String)"> + <summary> + Asserts that two directories are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory path string containing the value that is expected</param> + <param name="actual">A directory path string containing the actual value</param> + <param name="message">The message to display if directories are equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String)"> + <summary> + Asserts that two directories are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A directory path string containing the value that is expected</param> + <param name="actual">A directory path string containing the actual value</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String,System.Object[])"> + <summary> + Asserts that the directory is empty. If it is not empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String)"> + <summary> + Asserts that the directory is empty. If it is not empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo)"> + <summary> + Asserts that the directory is empty. If it is not empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String,System.Object[])"> + <summary> + Asserts that the directory is empty. If it is not empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String)"> + <summary> + Asserts that the directory is empty. If it is not empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String)"> + <summary> + Asserts that the directory is empty. If it is not empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String,System.Object[])"> + <summary> + Asserts that the directory is not empty. If it is empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String)"> + <summary> + Asserts that the directory is not empty. If it is empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo)"> + <summary> + Asserts that the directory is not empty. If it is empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String,System.Object[])"> + <summary> + Asserts that the directory is not empty. If it is empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String)"> + <summary> + Asserts that the directory is not empty. If it is empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="message">The message to display if directories are not equal</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String)"> + <summary> + Asserts that the directory is not empty. If it is empty + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])"> + <summary> + Asserts that path contains actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)"> + <summary> + Asserts that path contains actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)"> + <summary> + Asserts that path contains actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that path contains actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String)"> + <summary> + Asserts that path contains actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String)"> + <summary> + Asserts that path contains actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])"> + <summary> + Asserts that path does not contain actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)"> + <summary> + Asserts that path does not contain actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)"> + <summary> + Asserts that path does not contain actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that path does not contain actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String)"> + <summary> + Asserts that path does not contain actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + <param name="message">The message to display if directory is not within the path</param> + </member> + <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String)"> + <summary> + Asserts that path does not contain actual as a subdirectory or + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="directory">A directory to search</param> + <param name="actual">sub-directory asserted to exist under directory</param> + </member> + <member name="T:NUnit.Framework.FileAssert"> + <summary> + Summary description for FileAssert. + </summary> + </member> + <member name="M:NUnit.Framework.FileAssert.Equals(System.Object,System.Object)"> + <summary> + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.FileAssert.ReferenceEquals(System.Object,System.Object)"> + <summary> + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.FileAssert.#ctor"> + <summary> + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + </summary> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])"> + <summary> + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected Stream</param> + <param name="actual">The actual Stream</param> + <param name="message">The message to display if Streams are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String)"> + <summary> + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected Stream</param> + <param name="actual">The actual Stream</param> + <param name="message">The message to display if objects are not equal</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream)"> + <summary> + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected Stream</param> + <param name="actual">The actual Stream</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])"> + <summary> + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A file containing the value that is expected</param> + <param name="actual">A file containing the actual value</param> + <param name="message">The message to display if Streams are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)"> + <summary> + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A file containing the value that is expected</param> + <param name="actual">A file containing the actual value</param> + <param name="message">The message to display if objects are not equal</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo)"> + <summary> + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A file containing the value that is expected</param> + <param name="actual">A file containing the actual value</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String,System.Object[])"> + <summary> + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The path to a file containing the value that is expected</param> + <param name="actual">The path to a file containing the actual value</param> + <param name="message">The message to display if Streams are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String)"> + <summary> + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The path to a file containing the value that is expected</param> + <param name="actual">The path to a file containing the actual value</param> + <param name="message">The message to display if objects are not equal</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String)"> + <summary> + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The path to a file containing the value that is expected</param> + <param name="actual">The path to a file containing the actual value</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])"> + <summary> + Asserts that two Streams are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected Stream</param> + <param name="actual">The actual Stream</param> + <param name="message">The message to be displayed when the two Stream are the same.</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String)"> + <summary> + Asserts that two Streams are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected Stream</param> + <param name="actual">The actual Stream</param> + <param name="message">The message to be displayed when the Streams are the same.</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream)"> + <summary> + Asserts that two Streams are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The expected Stream</param> + <param name="actual">The actual Stream</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])"> + <summary> + Asserts that two files are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A file containing the value that is expected</param> + <param name="actual">A file containing the actual value</param> + <param name="message">The message to display if Streams are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)"> + <summary> + Asserts that two files are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A file containing the value that is expected</param> + <param name="actual">A file containing the actual value</param> + <param name="message">The message to display if objects are not equal</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo)"> + <summary> + Asserts that two files are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">A file containing the value that is expected</param> + <param name="actual">A file containing the actual value</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that two files are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The path to a file containing the value that is expected</param> + <param name="actual">The path to a file containing the actual value</param> + <param name="message">The message to display if Streams are not equal</param> + <param name="args">Arguments to be used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String)"> + <summary> + Asserts that two files are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The path to a file containing the value that is expected</param> + <param name="actual">The path to a file containing the actual value</param> + <param name="message">The message to display if objects are not equal</param> + </member> + <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String)"> + <summary> + Asserts that two files are not equal. If they are equal + an <see cref="T:NUnit.Framework.AssertionException"/> is thrown. + </summary> + <param name="expected">The path to a file containing the value that is expected</param> + <param name="actual">The path to a file containing the actual value</param> + </member> + <member name="T:NUnit.Framework.GlobalSettings"> + <summary> + GlobalSettings is a place for setting default values used + by the framework in performing asserts. + </summary> + </member> + <member name="F:NUnit.Framework.GlobalSettings.DefaultFloatingPointTolerance"> + <summary> + Default tolerance for floating point equality + </summary> + </member> + <member name="T:NUnit.Framework.Guard"> + <summary> + Class used to guard against unexpected argument values + by throwing an appropriate exception. + </summary> + </member> + <member name="M:NUnit.Framework.Guard.ArgumentNotNull(System.Object,System.String)"> + <summary> + Throws an exception if an argument is null + </summary> + <param name="value">The value to be tested</param> + <param name="name">The name of the argument</param> + </member> + <member name="M:NUnit.Framework.Guard.ArgumentNotNullOrEmpty(System.String,System.String)"> + <summary> + Throws an exception if a string argument is null or empty + </summary> + <param name="value">The value to be tested</param> + <param name="name">The name of the argument</param> + </member> + <member name="T:NUnit.Framework.Has"> + <summary> + Helper class with properties and methods that supply + a number of constraints used in Asserts. + </summary> + </member> + <member name="M:NUnit.Framework.Has.Exactly(System.Int32)"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding only if a specified number of them succeed. + </summary> + </member> + <member name="M:NUnit.Framework.Has.Property(System.String)"> + <summary> + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + </summary> + </member> + <member name="M:NUnit.Framework.Has.Attribute(System.Type)"> + <summary> + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + </summary> + </member> + <member name="M:NUnit.Framework.Has.Attribute``1"> + <summary> + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + </summary> + </member> + <member name="M:NUnit.Framework.Has.Member(System.Object)"> + <summary> + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + </summary> + </member> + <member name="P:NUnit.Framework.Has.No"> + <summary> + Returns a ConstraintExpression that negates any + following constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Has.All"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + </summary> + </member> + <member name="P:NUnit.Framework.Has.Some"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + </summary> + </member> + <member name="P:NUnit.Framework.Has.None"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + </summary> + </member> + <member name="P:NUnit.Framework.Has.Length"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Has.Count"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Has.Message"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Has.InnerException"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + </summary> + </member> + <member name="T:NUnit.Framework.IExpectException"> + <summary> + Interface implemented by a user fixture in order to + validate any expected exceptions. It is only called + for test methods marked with the ExpectedException + attribute. + </summary> + </member> + <member name="M:NUnit.Framework.IExpectException.HandleException(System.Exception)"> + <summary> + Method to handle an expected exception + </summary> + <param name="ex">The exception to be handled</param> + </member> + <member name="T:NUnit.Framework.Is"> + <summary> + Helper class with properties and methods that supply + a number of constraints used in Asserts. + </summary> + </member> + <member name="M:NUnit.Framework.Is.EqualTo(System.Object)"> + <summary> + Returns a constraint that tests two items for equality + </summary> + </member> + <member name="M:NUnit.Framework.Is.SameAs(System.Object)"> + <summary> + Returns a constraint that tests that two references are the same object + </summary> + </member> + <member name="M:NUnit.Framework.Is.GreaterThan(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Is.GreaterThanOrEqualTo(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Is.AtLeast(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Is.LessThan(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Is.LessThanOrEqualTo(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Is.AtMost(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Is.TypeOf(System.Type)"> + <summary> + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.TypeOf``1"> + <summary> + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.InstanceOf(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Is.InstanceOf``1"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Is.InstanceOfType(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Is.InstanceOfType``1"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Is.AssignableFrom(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.AssignableFrom``1"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.AssignableTo(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.AssignableTo``1"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.EquivalentTo(System.Collections.IEnumerable)"> + <summary> + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.SubsetOf(System.Collections.IEnumerable)"> + <summary> + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.StringContaining(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.StringStarting(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.StringEnding(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.StringMatching(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value matches the regular expression supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Is.SamePath(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Is.SubPath(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is under an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Is.SamePathOrUnder(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Is.InRange``1(``0,``0)"> + <summary> + Returns a constraint that tests whether the actual value falls + within a specified range. + </summary> + </member> + <member name="P:NUnit.Framework.Is.Not"> + <summary> + Returns a ConstraintExpression that negates any + following constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Is.All"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + </summary> + </member> + <member name="P:NUnit.Framework.Is.Null"> + <summary> + Returns a constraint that tests for null + </summary> + </member> + <member name="P:NUnit.Framework.Is.True"> + <summary> + Returns a constraint that tests for True + </summary> + </member> + <member name="P:NUnit.Framework.Is.False"> + <summary> + Returns a constraint that tests for False + </summary> + </member> + <member name="P:NUnit.Framework.Is.Positive"> + <summary> + Returns a constraint that tests for a positive value + </summary> + </member> + <member name="P:NUnit.Framework.Is.Negative"> + <summary> + Returns a constraint that tests for a negative value + </summary> + </member> + <member name="P:NUnit.Framework.Is.NaN"> + <summary> + Returns a constraint that tests for NaN + </summary> + </member> + <member name="P:NUnit.Framework.Is.Empty"> + <summary> + Returns a constraint that tests for empty + </summary> + </member> + <member name="P:NUnit.Framework.Is.Unique"> + <summary> + Returns a constraint that tests whether a collection + contains all unique items. + </summary> + </member> + <member name="P:NUnit.Framework.Is.BinarySerializable"> + <summary> + Returns a constraint that tests whether an object graph is serializable in binary format. + </summary> + </member> + <member name="P:NUnit.Framework.Is.XmlSerializable"> + <summary> + Returns a constraint that tests whether an object graph is serializable in xml format. + </summary> + </member> + <member name="P:NUnit.Framework.Is.Ordered"> + <summary> + Returns a constraint that tests whether a collection is ordered + </summary> + </member> + <member name="T:NUnit.Framework.ITestCaseData"> + <summary> + The ITestCaseData interface is implemented by a class + that is able to return complete testcases for use by + a parameterized test method. + + NOTE: This interface is used in both the framework + and the core, even though that results in two different + types. However, sharing the source code guarantees that + the various implementations will be compatible and that + the core is able to reflect successfully over the + framework implementations of ITestCaseData. + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.Arguments"> + <summary> + Gets the argument list to be provided to the test + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.Result"> + <summary> + Gets the expected result + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.HasExpectedResult"> + <summary> + Indicates whether a result has been specified. + This is necessary because the result may be + null, so it's value cannot be checked. + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.ExpectedException"> + <summary> + Gets the expected exception Type + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.ExpectedExceptionName"> + <summary> + Gets the FullName of the expected exception + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.TestName"> + <summary> + Gets the name to be used for the test + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.Description"> + <summary> + Gets the description of the test + </summary> + </member> + <member name="P:NUnit.Framework.ITestCaseData.Ignored"> + <summary> + Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored. + </summary> + <value><c>true</c> if ignored; otherwise, <c>false</c>.</value> + </member> + <member name="P:NUnit.Framework.ITestCaseData.Explicit"> + <summary> + Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is explicit. + </summary> + <value><c>true</c> if explicit; otherwise, <c>false</c>.</value> + </member> + <member name="P:NUnit.Framework.ITestCaseData.IgnoreReason"> + <summary> + Gets the ignore reason. + </summary> + <value>The ignore reason.</value> + </member> + <member name="T:NUnit.Framework.Iz"> + <summary> + The Iz class is a synonym for Is intended for use in VB, + which regards Is as a keyword. + </summary> + </member> + <member name="T:NUnit.Framework.List"> + <summary> + The List class is a helper class with properties and methods + that supply a number of constraints used with lists and collections. + </summary> + </member> + <member name="M:NUnit.Framework.List.Map(System.Collections.ICollection)"> + <summary> + List.Map returns a ListMapper, which can be used to map + the original collection to another collection. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="T:NUnit.Framework.ListMapper"> + <summary> + ListMapper is used to transform a collection used as an actual argument + producing another collection to be used in the assertion. + </summary> + </member> + <member name="M:NUnit.Framework.ListMapper.#ctor(System.Collections.ICollection)"> + <summary> + Construct a ListMapper based on a collection + </summary> + <param name="original">The collection to be transformed</param> + </member> + <member name="M:NUnit.Framework.ListMapper.Property(System.String)"> + <summary> + Produces a collection containing all the values of a property + </summary> + <param name="name">The collection of property values</param> + <returns></returns> + </member> + <member name="T:NUnit.Framework.Randomizer"> + <summary> + Randomizer returns a set of random values in a repeatable + way, to allow re-running of tests if necessary. + </summary> + </member> + <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.MemberInfo)"> + <summary> + Get a randomizer for a particular member, returning + one that has already been created if it exists. + This ensures that the same values are generated + each time the tests are reloaded. + </summary> + </member> + <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.ParameterInfo)"> + <summary> + Get a randomizer for a particular parameter, returning + one that has already been created if it exists. + This ensures that the same values are generated + each time the tests are reloaded. + </summary> + </member> + <member name="M:NUnit.Framework.Randomizer.#ctor"> + <summary> + Construct a randomizer using a random seed + </summary> + </member> + <member name="M:NUnit.Framework.Randomizer.#ctor(System.Int32)"> + <summary> + Construct a randomizer using a specified seed + </summary> + </member> + <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Int32)"> + <summary> + Return an array of random doubles between 0.0 and 1.0. + </summary> + <param name="count"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Double,System.Double,System.Int32)"> + <summary> + Return an array of random doubles with values in a specified range. + </summary> + </member> + <member name="M:NUnit.Framework.Randomizer.GetInts(System.Int32,System.Int32,System.Int32)"> + <summary> + Return an array of random ints with values in a specified range. + </summary> + </member> + <member name="P:NUnit.Framework.Randomizer.RandomSeed"> + <summary> + Get a random seed for use in creating a randomizer. + </summary> + </member> + <member name="T:NUnit.Framework.SpecialValue"> + <summary> + The SpecialValue enum is used to represent TestCase arguments + that cannot be used as arguments to an Attribute. + </summary> + </member> + <member name="F:NUnit.Framework.SpecialValue.Null"> + <summary> + Null represents a null value, which cannot be used as an + argument to an attribute under .NET 1.x + </summary> + </member> + <member name="T:NUnit.Framework.StringAssert"> + <summary> + Basic Asserts on strings. + </summary> + </member> + <member name="M:NUnit.Framework.StringAssert.Equals(System.Object,System.Object)"> + <summary> + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.StringAssert.ReferenceEquals(System.Object,System.Object)"> + <summary> + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + </summary> + <param name="a"></param> + <param name="b"></param> + </member> + <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string is found within another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String)"> + <summary> + Asserts that a string is found within another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String)"> + <summary> + Asserts that a string is found within another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string is not found within another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String)"> + <summary> + Asserts that a string is found within another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String)"> + <summary> + Asserts that a string is found within another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + </member> + <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string starts with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String)"> + <summary> + Asserts that a string starts with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String)"> + <summary> + Asserts that a string starts with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string does not start with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String)"> + <summary> + Asserts that a string does not start with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String)"> + <summary> + Asserts that a string does not start with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + </member> + <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string ends with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String)"> + <summary> + Asserts that a string ends with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String)"> + <summary> + Asserts that a string ends with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string does not end with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String)"> + <summary> + Asserts that a string does not end with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String)"> + <summary> + Asserts that a string does not end with another string. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The string to be examined</param> + </member> + <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that two strings are equal, without regard to case. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String)"> + <summary> + Asserts that two strings are equal, without regard to case. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String)"> + <summary> + Asserts that two strings are equal, without regard to case. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The actual string</param> + </member> + <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that two strings are not equal, without regard to case. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String)"> + <summary> + Asserts that two strings are Notequal, without regard to case. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String)"> + <summary> + Asserts that two strings are not equal, without regard to case. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The actual string</param> + </member> + <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string matches an expected regular expression pattern. + </summary> + <param name="pattern">The regex pattern to be matched</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String)"> + <summary> + Asserts that a string matches an expected regular expression pattern. + </summary> + <param name="pattern">The regex pattern to be matched</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String)"> + <summary> + Asserts that a string matches an expected regular expression pattern. + </summary> + <param name="pattern">The regex pattern to be matched</param> + <param name="actual">The actual string</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String,System.Object[])"> + <summary> + Asserts that a string does not match an expected regular expression pattern. + </summary> + <param name="pattern">The regex pattern to be used</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + <param name="args">Arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String)"> + <summary> + Asserts that a string does not match an expected regular expression pattern. + </summary> + <param name="pattern">The regex pattern to be used</param> + <param name="actual">The actual string</param> + <param name="message">The message to display in case of failure</param> + </member> + <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String)"> + <summary> + Asserts that a string does not match an expected regular expression pattern. + </summary> + <param name="pattern">The regex pattern to be used</param> + <param name="actual">The actual string</param> + </member> + <member name="T:NUnit.Framework.TestCaseData"> + <summary> + The TestCaseData class represents a set of arguments + and other parameter info to be used for a parameterized + test case. It provides a number of instance modifiers + for use in initializing the test case. + + Note: Instance modifiers are getters that return + the same instance after modifying it's state. + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.arguments"> + <summary> + The argument list to be provided to the test + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.expectedResult"> + <summary> + The expected result to be returned + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.hasExpectedResult"> + <summary> + Set to true if this has an expected result + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.expectedExceptionType"> + <summary> + The expected exception Type + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.expectedExceptionName"> + <summary> + The FullName of the expected exception + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.testName"> + <summary> + The name to be used for the test + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.description"> + <summary> + The description of the test + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.properties"> + <summary> + A dictionary of properties, used to add information + to tests without requiring the class to change. + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.isIgnored"> + <summary> + If true, indicates that the test case is to be ignored + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.isExplicit"> + <summary> + If true, indicates that the test case is marked explicit + </summary> + </member> + <member name="F:NUnit.Framework.TestCaseData.ignoreReason"> + <summary> + The reason for ignoring a test case + </summary> + </member> + <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object[])"> + <summary> + Initializes a new instance of the <see cref="T:TestCaseData"/> class. + </summary> + <param name="args">The arguments.</param> + </member> + <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:TestCaseData"/> class. + </summary> + <param name="arg">The argument.</param> + </member> + <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:TestCaseData"/> class. + </summary> + <param name="arg1">The first argument.</param> + <param name="arg2">The second argument.</param> + </member> + <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object,System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:TestCaseData"/> class. + </summary> + <param name="arg1">The first argument.</param> + <param name="arg2">The second argument.</param> + <param name="arg3">The third argument.</param> + </member> + <member name="M:NUnit.Framework.TestCaseData.Returns(System.Object)"> + <summary> + Sets the expected result for the test + </summary> + <param name="result">The expected result</param> + <returns>A modified TestCaseData</returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.Throws(System.Type)"> + <summary> + Sets the expected exception type for the test + </summary> + <param name="exceptionType">Type of the expected exception.</param> + <returns>The modified TestCaseData instance</returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.Throws(System.String)"> + <summary> + Sets the expected exception type for the test + </summary> + <param name="exceptionName">FullName of the expected exception.</param> + <returns>The modified TestCaseData instance</returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.SetName(System.String)"> + <summary> + Sets the name of the test case + </summary> + <returns>The modified TestCaseData instance</returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.SetDescription(System.String)"> + <summary> + Sets the description for the test case + being constructed. + </summary> + <param name="description">The description.</param> + <returns>The modified TestCaseData instance.</returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.SetCategory(System.String)"> + <summary> + Applies a category to the test + </summary> + <param name="category"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.String)"> + <summary> + Applies a named property to the test + </summary> + <param name="propName"></param> + <param name="propValue"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Int32)"> + <summary> + Applies a named property to the test + </summary> + <param name="propName"></param> + <param name="propValue"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Double)"> + <summary> + Applies a named property to the test + </summary> + <param name="propName"></param> + <param name="propValue"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.Ignore"> + <summary> + Ignores this TestCase. + </summary> + <returns></returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.Ignore(System.String)"> + <summary> + Ignores this TestCase, specifying the reason. + </summary> + <param name="reason">The reason.</param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.MakeExplicit"> + <summary> + Marks this TestCase as Explicit + </summary> + <returns></returns> + </member> + <member name="M:NUnit.Framework.TestCaseData.MakeExplicit(System.String)"> + <summary> + Marks this TestCase as Explicit, specifying the reason. + </summary> + <param name="reason">The reason.</param> + <returns></returns> + </member> + <member name="P:NUnit.Framework.TestCaseData.Arguments"> + <summary> + Gets the argument list to be provided to the test + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.Result"> + <summary> + Gets the expected result + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.HasExpectedResult"> + <summary> + Returns true if the result has been set + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.ExpectedException"> + <summary> + Gets the expected exception Type + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.ExpectedExceptionName"> + <summary> + Gets the FullName of the expected exception + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.TestName"> + <summary> + Gets the name to be used for the test + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.Description"> + <summary> + Gets the description of the test + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.Ignored"> + <summary> + Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored. + </summary> + <value><c>true</c> if ignored; otherwise, <c>false</c>.</value> + </member> + <member name="P:NUnit.Framework.TestCaseData.Explicit"> + <summary> + Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is explicit. + </summary> + <value><c>true</c> if explicit; otherwise, <c>false</c>.</value> + </member> + <member name="P:NUnit.Framework.TestCaseData.IgnoreReason"> + <summary> + Gets the ignore reason. + </summary> + <value>The ignore reason.</value> + </member> + <member name="P:NUnit.Framework.TestCaseData.Categories"> + <summary> + Gets a list of categories associated with this test. + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseData.Properties"> + <summary> + Gets the property dictionary for this test + </summary> + </member> + <member name="T:NUnit.Framework.TestContext"> + <summary> + Provide the context information of the current test + </summary> + </member> + <member name="M:NUnit.Framework.TestContext.#ctor(System.Collections.IDictionary)"> + <summary> + Constructs a TestContext using the provided context dictionary + </summary> + <param name="context">A context dictionary</param> + </member> + <member name="P:NUnit.Framework.TestContext.CurrentContext"> + <summary> + Get the current test context. This is created + as needed. The user may save the context for + use within a test, but it should not be used + outside the test for which it is created. + </summary> + </member> + <member name="P:NUnit.Framework.TestContext.Test"> + <summary> + Gets a TestAdapter representing the currently executing test in this context. + </summary> + </member> + <member name="P:NUnit.Framework.TestContext.Result"> + <summary> + Gets a ResultAdapter representing the current result for the test + executing in this context. + </summary> + </member> + <member name="P:NUnit.Framework.TestContext.TestDirectory"> + <summary> + Gets the directory containing the current test assembly. + </summary> + </member> + <member name="P:NUnit.Framework.TestContext.WorkDirectory"> + <summary> + Gets the directory to be used for outputing files created + by this test run. + </summary> + </member> + <member name="T:NUnit.Framework.TestContext.TestAdapter"> + <summary> + TestAdapter adapts a Test for consumption by + the user test code. + </summary> + </member> + <member name="M:NUnit.Framework.TestContext.TestAdapter.#ctor(System.Collections.IDictionary)"> + <summary> + Constructs a TestAdapter for this context + </summary> + <param name="context">The context dictionary</param> + </member> + <member name="P:NUnit.Framework.TestContext.TestAdapter.Name"> + <summary> + The name of the test. + </summary> + </member> + <member name="P:NUnit.Framework.TestContext.TestAdapter.FullName"> + <summary> + The FullName of the test + </summary> + </member> + <member name="P:NUnit.Framework.TestContext.TestAdapter.Properties"> + <summary> + The properties of the test. + </summary> + </member> + <member name="T:NUnit.Framework.TestContext.ResultAdapter"> + <summary> + ResultAdapter adapts a TestResult for consumption by + the user test code. + </summary> + </member> + <member name="M:NUnit.Framework.TestContext.ResultAdapter.#ctor(System.Collections.IDictionary)"> + <summary> + Construct a ResultAdapter for a context + </summary> + <param name="context">The context holding the result</param> + </member> + <member name="P:NUnit.Framework.TestContext.ResultAdapter.State"> + <summary> + The TestState of current test. This maps to the ResultState + used in nunit.core and is subject to change in the future. + </summary> + </member> + <member name="P:NUnit.Framework.TestContext.ResultAdapter.Status"> + <summary> + The TestStatus of current test. This enum will be used + in future versions of NUnit and so is to be preferred + to the TestState value. + </summary> + </member> + <member name="T:NUnit.Framework.TestDetails"> + <summary> + Provides details about a test + </summary> + </member> + <member name="M:NUnit.Framework.TestDetails.#ctor(System.Object,System.Reflection.MethodInfo,System.String,System.String,System.Boolean)"> + <summary> + Creates an instance of TestDetails + </summary> + <param name="fixture">The fixture that the test is a member of, if available.</param> + <param name="method">The method that implements the test, if available.</param> + <param name="fullName">The full name of the test.</param> + <param name="type">A string representing the type of test, e.g. "Test Case".</param> + <param name="isSuite">Indicates if the test represents a suite of tests.</param> + </member> + <member name="P:NUnit.Framework.TestDetails.Fixture"> + <summary> + The fixture that the test is a member of, if available. + </summary> + </member> + <member name="P:NUnit.Framework.TestDetails.Method"> + <summary> + The method that implements the test, if available. + </summary> + </member> + <member name="P:NUnit.Framework.TestDetails.FullName"> + <summary> + The full name of the test. + </summary> + </member> + <member name="P:NUnit.Framework.TestDetails.Type"> + <summary> + A string representing the type of test, e.g. "Test Case". + </summary> + </member> + <member name="P:NUnit.Framework.TestDetails.IsSuite"> + <summary> + Indicates if the test represents a suite of tests. + </summary> + </member> + <member name="T:NUnit.Framework.TestState"> + <summary> + The ResultState enum indicates the result of running a test + </summary> + </member> + <member name="F:NUnit.Framework.TestState.Inconclusive"> + <summary> + The result is inconclusive + </summary> + </member> + <member name="F:NUnit.Framework.TestState.NotRunnable"> + <summary> + The test was not runnable. + </summary> + </member> + <member name="F:NUnit.Framework.TestState.Skipped"> + <summary> + The test has been skipped. + </summary> + </member> + <member name="F:NUnit.Framework.TestState.Ignored"> + <summary> + The test has been ignored. + </summary> + </member> + <member name="F:NUnit.Framework.TestState.Success"> + <summary> + The test succeeded + </summary> + </member> + <member name="F:NUnit.Framework.TestState.Failure"> + <summary> + The test failed + </summary> + </member> + <member name="F:NUnit.Framework.TestState.Error"> + <summary> + The test encountered an unexpected exception + </summary> + </member> + <member name="F:NUnit.Framework.TestState.Cancelled"> + <summary> + The test was cancelled by the user + </summary> + </member> + <member name="T:NUnit.Framework.TestStatus"> + <summary> + The TestStatus enum indicates the result of running a test + </summary> + </member> + <member name="F:NUnit.Framework.TestStatus.Inconclusive"> + <summary> + The test was inconclusive + </summary> + </member> + <member name="F:NUnit.Framework.TestStatus.Skipped"> + <summary> + The test has skipped + </summary> + </member> + <member name="F:NUnit.Framework.TestStatus.Passed"> + <summary> + The test succeeded + </summary> + </member> + <member name="F:NUnit.Framework.TestStatus.Failed"> + <summary> + The test failed + </summary> + </member> + <member name="T:NUnit.Framework.Text"> + <summary> + Helper class with static methods used to supply constraints + that operate on strings. + </summary> + </member> + <member name="M:NUnit.Framework.Text.Contains(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Text.DoesNotContain(System.String)"> + <summary> + Returns a constraint that fails if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Text.StartsWith(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Text.DoesNotStartWith(System.String)"> + <summary> + Returns a constraint that fails if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Text.EndsWith(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Text.DoesNotEndWith(System.String)"> + <summary> + Returns a constraint that fails if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Text.Matches(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Text.DoesNotMatch(System.String)"> + <summary> + Returns a constraint that fails if the actual + value matches the pattern supplied as an argument. + </summary> + </member> + <member name="P:NUnit.Framework.Text.All"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + </summary> + </member> + <member name="T:NUnit.Framework.TextMessageWriter"> + <summary> + TextMessageWriter writes constraint descriptions and messages + in displayable form as a text stream. It tailors the display + of individual message components to form the standard message + format of NUnit assertion failure messages. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.MessageWriter"> + <summary> + MessageWriter is the abstract base for classes that write + constraint descriptions and messages in some form. The + class has separate methods for writing various components + of a message, allowing implementations to tailor the + presentation as needed. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.#ctor"> + <summary> + Construct a MessageWriter given a culture + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.String,System.Object[])"> + <summary> + Method to write single line message with optional args, usually + written to precede the general failure message. + </summary> + <param name="message">The message to be written</param> + <param name="args">Any arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])"> + <summary> + Method to write single line message with optional args, usually + written to precede the general failure message, at a givel + indentation level. + </summary> + <param name="level">The indentation level of the message</param> + <param name="message">The message to be written</param> + <param name="args">Any arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)"> + <summary> + Display Expected and Actual lines for a constraint. This + is called by MessageWriter's default implementation of + WriteMessageTo and provides the generic two-line display. + </summary> + <param name="constraint">The constraint that failed</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object)"> + <summary> + Display Expected and Actual lines for given values. This + method may be called by constraints that need more control over + the display of actual and expected values than is provided + by the default implementation. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value causing the failure</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)"> + <summary> + Display Expected and Actual lines for given values, including + a tolerance value on the Expected line. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value causing the failure</param> + <param name="tolerance">The tolerance within which the test was made</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)"> + <summary> + Display the expected and actual string values on separate lines. + If the mismatch parameter is >=0, an additional line is displayed + line containing a caret that points to the mismatch point. + </summary> + <param name="expected">The expected string value</param> + <param name="actual">The actual string value</param> + <param name="mismatch">The point at which the strings don't match or -1</param> + <param name="ignoreCase">If true, case is ignored in locating the point where the strings differ</param> + <param name="clipping">If true, the strings should be clipped to fit the line</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteConnector(System.String)"> + <summary> + Writes the text for a connector. + </summary> + <param name="connector">The connector.</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WritePredicate(System.String)"> + <summary> + Writes the text for a predicate. + </summary> + <param name="predicate">The predicate.</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteExpectedValue(System.Object)"> + <summary> + Writes the text for an expected value. + </summary> + <param name="expected">The expected value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteModifier(System.String)"> + <summary> + Writes the text for a modifier + </summary> + <param name="modifier">The modifier.</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteActualValue(System.Object)"> + <summary> + Writes the text for an actual value. + </summary> + <param name="actual">The actual value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteValue(System.Object)"> + <summary> + Writes the text for a generalized value. + </summary> + <param name="val">The value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteCollectionElements(System.Collections.IEnumerable,System.Int32,System.Int32)"> + <summary> + Writes the text for a collection value, + starting at a particular point, to a max length + </summary> + <param name="collection">The collection containing elements to write.</param> + <param name="start">The starting point of the elements to write</param> + <param name="max">The maximum number of elements to write</param> + </member> + <member name="P:NUnit.Framework.Constraints.MessageWriter.MaxLineLength"> + <summary> + Abstract method to get the max line length + </summary> + </member> + <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Expected"> + <summary> + Prefix used for the expected value line of a message + </summary> + </member> + <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Actual"> + <summary> + Prefix used for the actual value line of a message + </summary> + </member> + <member name="F:NUnit.Framework.TextMessageWriter.PrefixLength"> + <summary> + Length of a message prefix + </summary> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.#ctor"> + <summary> + Construct a TextMessageWriter + </summary> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.#ctor(System.String,System.Object[])"> + <summary> + Construct a TextMessageWriter, specifying a user message + and optional formatting arguments. + </summary> + <param name="userMessage"></param> + <param name="args"></param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])"> + <summary> + Method to write single line message with optional args, usually + written to precede the general failure message, at a givel + indentation level. + </summary> + <param name="level">The indentation level of the message</param> + <param name="message">The message to be written</param> + <param name="args">Any arguments used in formatting the message</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)"> + <summary> + Display Expected and Actual lines for a constraint. This + is called by MessageWriter's default implementation of + WriteMessageTo and provides the generic two-line display. + </summary> + <param name="constraint">The constraint that failed</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object)"> + <summary> + Display Expected and Actual lines for given values. This + method may be called by constraints that need more control over + the display of actual and expected values than is provided + by the default implementation. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value causing the failure</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)"> + <summary> + Display Expected and Actual lines for given values, including + a tolerance value on the expected line. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value causing the failure</param> + <param name="tolerance">The tolerance within which the test was made</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)"> + <summary> + Display the expected and actual string values on separate lines. + If the mismatch parameter is >=0, an additional line is displayed + line containing a caret that points to the mismatch point. + </summary> + <param name="expected">The expected string value</param> + <param name="actual">The actual string value</param> + <param name="mismatch">The point at which the strings don't match or -1</param> + <param name="ignoreCase">If true, case is ignored in string comparisons</param> + <param name="clipping">If true, clip the strings to fit the max line length</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteConnector(System.String)"> + <summary> + Writes the text for a connector. + </summary> + <param name="connector">The connector.</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WritePredicate(System.String)"> + <summary> + Writes the text for a predicate. + </summary> + <param name="predicate">The predicate.</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteModifier(System.String)"> + <summary> + Write the text for a modifier. + </summary> + <param name="modifier">The modifier.</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedValue(System.Object)"> + <summary> + Writes the text for an expected value. + </summary> + <param name="expected">The expected value.</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteActualValue(System.Object)"> + <summary> + Writes the text for an actual value. + </summary> + <param name="actual">The actual value.</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteValue(System.Object)"> + <summary> + Writes the text for a generalized value. + </summary> + <param name="val">The value.</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteCollectionElements(System.Collections.IEnumerable,System.Int32,System.Int32)"> + <summary> + Writes the text for a collection value, + starting at a particular point, to a max length + </summary> + <param name="collection">The collection containing elements to write.</param> + <param name="start">The starting point of the elements to write</param> + <param name="max">The maximum number of elements to write</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(NUnit.Framework.Constraints.Constraint)"> + <summary> + Write the generic 'Expected' line for a constraint + </summary> + <param name="constraint">The constraint that failed</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object)"> + <summary> + Write the generic 'Expected' line for a given value + </summary> + <param name="expected">The expected value</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object,NUnit.Framework.Constraints.Tolerance)"> + <summary> + Write the generic 'Expected' line for a given value + and tolerance. + </summary> + <param name="expected">The expected value</param> + <param name="tolerance">The tolerance within which the test was made</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(NUnit.Framework.Constraints.Constraint)"> + <summary> + Write the generic 'Actual' line for a constraint + </summary> + <param name="constraint">The constraint for which the actual value is to be written</param> + </member> + <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(System.Object)"> + <summary> + Write the generic 'Actual' line for a given value + </summary> + <param name="actual">The actual value causing a failure</param> + </member> + <member name="P:NUnit.Framework.TextMessageWriter.MaxLineLength"> + <summary> + Gets or sets the maximum line length for this writer + </summary> + </member> + <member name="T:NUnit.Framework.Throws"> + <summary> + Helper class with properties and methods that supply + constraints that operate on exceptions. + </summary> + </member> + <member name="M:NUnit.Framework.Throws.TypeOf(System.Type)"> + <summary> + Creates a constraint specifying the exact type of exception expected + </summary> + </member> + <member name="M:NUnit.Framework.Throws.TypeOf``1"> + <summary> + Creates a constraint specifying the exact type of exception expected + </summary> + </member> + <member name="M:NUnit.Framework.Throws.InstanceOf(System.Type)"> + <summary> + Creates a constraint specifying the type of exception expected + </summary> + </member> + <member name="M:NUnit.Framework.Throws.InstanceOf``1"> + <summary> + Creates a constraint specifying the type of exception expected + </summary> + </member> + <member name="P:NUnit.Framework.Throws.Exception"> + <summary> + Creates a constraint specifying an expected exception + </summary> + </member> + <member name="P:NUnit.Framework.Throws.InnerException"> + <summary> + Creates a constraint specifying an exception with a given InnerException + </summary> + </member> + <member name="P:NUnit.Framework.Throws.TargetInvocationException"> + <summary> + Creates a constraint specifying an expected TargetInvocationException + </summary> + </member> + <member name="P:NUnit.Framework.Throws.ArgumentException"> + <summary> + Creates a constraint specifying an expected TargetInvocationException + </summary> + </member> + <member name="P:NUnit.Framework.Throws.InvalidOperationException"> + <summary> + Creates a constraint specifying an expected TargetInvocationException + </summary> + </member> + <member name="P:NUnit.Framework.Throws.Nothing"> + <summary> + Creates a constraint specifying that no exception is thrown + </summary> + </member> + <member name="T:NUnit.Framework.CategoryAttribute"> + <summary> + Attribute used to apply a category to a test + </summary> + </member> + <member name="F:NUnit.Framework.CategoryAttribute.categoryName"> + <summary> + The name of the category + </summary> + </member> + <member name="M:NUnit.Framework.CategoryAttribute.#ctor(System.String)"> + <summary> + Construct attribute for a given category based on + a name. The name may not contain the characters ',', + '+', '-' or '!'. However, this is not checked in the + constructor since it would cause an error to arise at + as the test was loaded without giving a clear indication + of where the problem is located. The error is handled + in NUnitFramework.cs by marking the test as not + runnable. + </summary> + <param name="name">The name of the category</param> + </member> + <member name="M:NUnit.Framework.CategoryAttribute.#ctor"> + <summary> + Protected constructor uses the Type name as the name + of the category. + </summary> + </member> + <member name="P:NUnit.Framework.CategoryAttribute.Name"> + <summary> + The name of the category + </summary> + </member> + <member name="T:NUnit.Framework.DatapointAttribute"> + <summary> + Used to mark a field for use as a datapoint when executing a theory + within the same fixture that requires an argument of the field's Type. + </summary> + </member> + <member name="T:NUnit.Framework.DatapointsAttribute"> + <summary> + Used to mark an array as containing a set of datapoints to be used + executing a theory within the same fixture that requires an argument + of the Type of the array elements. + </summary> + </member> + <member name="T:NUnit.Framework.DescriptionAttribute"> + <summary> + Attribute used to provide descriptive text about a + test case or fixture. + </summary> + </member> + <member name="M:NUnit.Framework.DescriptionAttribute.#ctor(System.String)"> + <summary> + Construct the attribute + </summary> + <param name="description">Text describing the test</param> + </member> + <member name="P:NUnit.Framework.DescriptionAttribute.Description"> + <summary> + Gets the test description + </summary> + </member> + <member name="T:NUnit.Framework.MessageMatch"> + <summary> + Enumeration indicating how the expected message parameter is to be used + </summary> + </member> + <member name="F:NUnit.Framework.MessageMatch.Exact"> + Expect an exact match + </member> + <member name="F:NUnit.Framework.MessageMatch.Contains"> + Expect a message containing the parameter string + </member> + <member name="F:NUnit.Framework.MessageMatch.Regex"> + Match the regular expression provided as a parameter + </member> + <member name="F:NUnit.Framework.MessageMatch.StartsWith"> + Expect a message that starts with the parameter string + </member> + <member name="T:NUnit.Framework.ExpectedExceptionAttribute"> + <summary> + ExpectedExceptionAttribute + </summary> + + </member> + <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor"> + <summary> + Constructor for a non-specific exception + </summary> + </member> + <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.Type)"> + <summary> + Constructor for a given type of exception + </summary> + <param name="exceptionType">The type of the expected exception</param> + </member> + <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.String)"> + <summary> + Constructor for a given exception name + </summary> + <param name="exceptionName">The full name of the expected exception</param> + </member> + <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedException"> + <summary> + Gets or sets the expected exception type + </summary> + </member> + <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedExceptionName"> + <summary> + Gets or sets the full Type name of the expected exception + </summary> + </member> + <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedMessage"> + <summary> + Gets or sets the expected message text + </summary> + </member> + <member name="P:NUnit.Framework.ExpectedExceptionAttribute.UserMessage"> + <summary> + Gets or sets the user message displayed in case of failure + </summary> + </member> + <member name="P:NUnit.Framework.ExpectedExceptionAttribute.MatchType"> + <summary> + Gets or sets the type of match to be performed on the expected message + </summary> + </member> + <member name="P:NUnit.Framework.ExpectedExceptionAttribute.Handler"> + <summary> + Gets the name of a method to be used as an exception handler + </summary> + </member> + <member name="T:NUnit.Framework.ExplicitAttribute"> + <summary> + ExplicitAttribute marks a test or test fixture so that it will + only be run if explicitly executed from the gui or command line + or if it is included by use of a filter. The test will not be + run simply because an enclosing suite is run. + </summary> + </member> + <member name="M:NUnit.Framework.ExplicitAttribute.#ctor"> + <summary> + Default constructor + </summary> + </member> + <member name="M:NUnit.Framework.ExplicitAttribute.#ctor(System.String)"> + <summary> + Constructor with a reason + </summary> + <param name="reason">The reason test is marked explicit</param> + </member> + <member name="P:NUnit.Framework.ExplicitAttribute.Reason"> + <summary> + The reason test is marked explicit + </summary> + </member> + <member name="T:NUnit.Framework.IgnoreAttribute"> + <summary> + Attribute used to mark a test that is to be ignored. + Ignored tests result in a warning message when the + tests are run. + </summary> + </member> + <member name="M:NUnit.Framework.IgnoreAttribute.#ctor"> + <summary> + Constructs the attribute without giving a reason + for ignoring the test. + </summary> + </member> + <member name="M:NUnit.Framework.IgnoreAttribute.#ctor(System.String)"> + <summary> + Constructs the attribute giving a reason for ignoring the test + </summary> + <param name="reason">The reason for ignoring the test</param> + </member> + <member name="P:NUnit.Framework.IgnoreAttribute.Reason"> + <summary> + The reason for ignoring a test + </summary> + </member> + <member name="T:NUnit.Framework.IncludeExcludeAttribute"> + <summary> + Abstract base for Attributes that are used to include tests + in the test run based on environmental settings. + </summary> + </member> + <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor"> + <summary> + Constructor with no included items specified, for use + with named property syntax. + </summary> + </member> + <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor(System.String)"> + <summary> + Constructor taking one or more included items + </summary> + <param name="include">Comma-delimited list of included items</param> + </member> + <member name="P:NUnit.Framework.IncludeExcludeAttribute.Include"> + <summary> + Name of the item that is needed in order for + a test to run. Multiple itemss may be given, + separated by a comma. + </summary> + </member> + <member name="P:NUnit.Framework.IncludeExcludeAttribute.Exclude"> + <summary> + Name of the item to be excluded. Multiple items + may be given, separated by a comma. + </summary> + </member> + <member name="P:NUnit.Framework.IncludeExcludeAttribute.Reason"> + <summary> + The reason for including or excluding the test + </summary> + </member> + <member name="T:NUnit.Framework.PlatformAttribute"> + <summary> + PlatformAttribute is used to mark a test fixture or an + individual method as applying to a particular platform only. + </summary> + </member> + <member name="M:NUnit.Framework.PlatformAttribute.#ctor"> + <summary> + Constructor with no platforms specified, for use + with named property syntax. + </summary> + </member> + <member name="M:NUnit.Framework.PlatformAttribute.#ctor(System.String)"> + <summary> + Constructor taking one or more platforms + </summary> + <param name="platforms">Comma-deliminted list of platforms</param> + </member> + <member name="T:NUnit.Framework.CultureAttribute"> + <summary> + CultureAttribute is used to mark a test fixture or an + individual method as applying to a particular Culture only. + </summary> + </member> + <member name="M:NUnit.Framework.CultureAttribute.#ctor"> + <summary> + Constructor with no cultures specified, for use + with named property syntax. + </summary> + </member> + <member name="M:NUnit.Framework.CultureAttribute.#ctor(System.String)"> + <summary> + Constructor taking one or more cultures + </summary> + <param name="cultures">Comma-deliminted list of cultures</param> + </member> + <member name="T:NUnit.Framework.CombinatorialAttribute"> + <summary> + Marks a test to use a combinatorial join of any argument data + provided. NUnit will create a test case for every combination of + the arguments provided. This can result in a large number of test + cases and so should be used judiciously. This is the default join + type, so the attribute need not be used except as documentation. + </summary> + </member> + <member name="T:NUnit.Framework.PropertyAttribute"> + <summary> + PropertyAttribute is used to attach information to a test as a name/value pair.. + </summary> + </member> + <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.String)"> + <summary> + Construct a PropertyAttribute with a name and string value + </summary> + <param name="propertyName">The name of the property</param> + <param name="propertyValue">The property value</param> + </member> + <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Int32)"> + <summary> + Construct a PropertyAttribute with a name and int value + </summary> + <param name="propertyName">The name of the property</param> + <param name="propertyValue">The property value</param> + </member> + <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Double)"> + <summary> + Construct a PropertyAttribute with a name and double value + </summary> + <param name="propertyName">The name of the property</param> + <param name="propertyValue">The property value</param> + </member> + <member name="M:NUnit.Framework.PropertyAttribute.#ctor"> + <summary> + Constructor for derived classes that set the + property dictionary directly. + </summary> + </member> + <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.Object)"> + <summary> + Constructor for use by derived classes that use the + name of the type as the property name. Derived classes + must ensure that the Type of the property value is + a standard type supported by the BCL. Any custom + types will cause a serialization Exception when + in the client. + </summary> + </member> + <member name="P:NUnit.Framework.PropertyAttribute.Properties"> + <summary> + Gets the property dictionary for this attribute + </summary> + </member> + <member name="M:NUnit.Framework.CombinatorialAttribute.#ctor"> + <summary> + Default constructor + </summary> + </member> + <member name="T:NUnit.Framework.PairwiseAttribute"> + <summary> + Marks a test to use pairwise join of any argument data provided. + NUnit will attempt too excercise every pair of argument values at + least once, using as small a number of test cases as it can. With + only two arguments, this is the same as a combinatorial join. + </summary> + </member> + <member name="M:NUnit.Framework.PairwiseAttribute.#ctor"> + <summary> + Default constructor + </summary> + </member> + <member name="T:NUnit.Framework.SequentialAttribute"> + <summary> + Marks a test to use a sequential join of any argument data + provided. NUnit will use arguements for each parameter in + sequence, generating test cases up to the largest number + of argument values provided and using null for any arguments + for which it runs out of values. Normally, this should be + used with the same number of arguments for each parameter. + </summary> + </member> + <member name="M:NUnit.Framework.SequentialAttribute.#ctor"> + <summary> + Default constructor + </summary> + </member> + <member name="T:NUnit.Framework.MaxTimeAttribute"> + <summary> + Summary description for MaxTimeAttribute. + </summary> + </member> + <member name="M:NUnit.Framework.MaxTimeAttribute.#ctor(System.Int32)"> + <summary> + Construct a MaxTimeAttribute, given a time in milliseconds. + </summary> + <param name="milliseconds">The maximum elapsed time in milliseconds</param> + </member> + <member name="T:NUnit.Framework.RandomAttribute"> + <summary> + RandomAttribute is used to supply a set of random values + to a single parameter of a parameterized test. + </summary> + </member> + <member name="T:NUnit.Framework.ValuesAttribute"> + <summary> + ValuesAttribute is used to provide literal arguments for + an individual parameter of a test. + </summary> + </member> + <member name="T:NUnit.Framework.ParameterDataAttribute"> + <summary> + Abstract base class for attributes that apply to parameters + and supply data for the parameter. + </summary> + </member> + <member name="M:NUnit.Framework.ParameterDataAttribute.GetData(System.Reflection.ParameterInfo)"> + <summary> + Gets the data to be provided to the specified parameter + </summary> + </member> + <member name="F:NUnit.Framework.ValuesAttribute.data"> + <summary> + The collection of data to be returned. Must + be set by any derived attribute classes. + We use an object[] so that the individual + elements may have their type changed in GetData + if necessary. + </summary> + </member> + <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object)"> + <summary> + Construct with one argument + </summary> + <param name="arg1"></param> + </member> + <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object)"> + <summary> + Construct with two arguments + </summary> + <param name="arg1"></param> + <param name="arg2"></param> + </member> + <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object,System.Object)"> + <summary> + Construct with three arguments + </summary> + <param name="arg1"></param> + <param name="arg2"></param> + <param name="arg3"></param> + </member> + <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object[])"> + <summary> + Construct with an array of arguments + </summary> + <param name="args"></param> + </member> + <member name="M:NUnit.Framework.ValuesAttribute.GetData(System.Reflection.ParameterInfo)"> + <summary> + Get the collection of values to be used as arguments + </summary> + </member> + <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32)"> + <summary> + Construct a set of doubles from 0.0 to 1.0, + specifying only the count. + </summary> + <param name="count"></param> + </member> + <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Double,System.Double,System.Int32)"> + <summary> + Construct a set of doubles from min to max + </summary> + <param name="min"></param> + <param name="max"></param> + <param name="count"></param> + </member> + <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32,System.Int32,System.Int32)"> + <summary> + Construct a set of ints from min to max + </summary> + <param name="min"></param> + <param name="max"></param> + <param name="count"></param> + </member> + <member name="M:NUnit.Framework.RandomAttribute.GetData(System.Reflection.ParameterInfo)"> + <summary> + Get the collection of values to be used as arguments + </summary> + </member> + <member name="T:NUnit.Framework.RangeAttribute"> + <summary> + RangeAttribute is used to supply a range of values to an + individual parameter of a parameterized test. + </summary> + </member> + <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32)"> + <summary> + Construct a range of ints using default step of 1 + </summary> + <param name="from"></param> + <param name="to"></param> + </member> + <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32,System.Int32)"> + <summary> + Construct a range of ints specifying the step size + </summary> + <param name="from"></param> + <param name="to"></param> + <param name="step"></param> + </member> + <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int64,System.Int64,System.Int64)"> + <summary> + Construct a range of longs + </summary> + <param name="from"></param> + <param name="to"></param> + <param name="step"></param> + </member> + <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Double,System.Double,System.Double)"> + <summary> + Construct a range of doubles + </summary> + <param name="from"></param> + <param name="to"></param> + <param name="step"></param> + </member> + <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Single,System.Single,System.Single)"> + <summary> + Construct a range of floats + </summary> + <param name="from"></param> + <param name="to"></param> + <param name="step"></param> + </member> + <member name="T:NUnit.Framework.RepeatAttribute"> + <summary> + RepeatAttribute may be applied to test case in order + to run it multiple times. + </summary> + </member> + <member name="M:NUnit.Framework.RepeatAttribute.#ctor(System.Int32)"> + <summary> + Construct a RepeatAttribute + </summary> + <param name="count">The number of times to run the test</param> + </member> + <member name="T:NUnit.Framework.RequiredAddinAttribute"> + <summary> + RequiredAddinAttribute may be used to indicate the names of any addins + that must be present in order to run some or all of the tests in an + assembly. If the addin is not loaded, the entire assembly is marked + as NotRunnable. + </summary> + </member> + <member name="M:NUnit.Framework.RequiredAddinAttribute.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:RequiredAddinAttribute"/> class. + </summary> + <param name="requiredAddin">The required addin.</param> + </member> + <member name="P:NUnit.Framework.RequiredAddinAttribute.RequiredAddin"> + <summary> + Gets the name of required addin. + </summary> + <value>The required addin name.</value> + </member> + <member name="T:NUnit.Framework.SetCultureAttribute"> + <summary> + Summary description for SetCultureAttribute. + </summary> + </member> + <member name="M:NUnit.Framework.SetCultureAttribute.#ctor(System.String)"> + <summary> + Construct given the name of a culture + </summary> + <param name="culture"></param> + </member> + <member name="T:NUnit.Framework.SetUICultureAttribute"> + <summary> + Summary description for SetUICultureAttribute. + </summary> + </member> + <member name="M:NUnit.Framework.SetUICultureAttribute.#ctor(System.String)"> + <summary> + Construct given the name of a culture + </summary> + <param name="culture"></param> + </member> + <member name="T:NUnit.Framework.SetUpAttribute"> + <summary> + SetUpAttribute is used in a TestFixture to identify a method + that is called immediately before each test is run. It is + also used in a SetUpFixture to identify the method that is + called once, before any of the subordinate tests are run. + </summary> + </member> + <member name="T:NUnit.Framework.SetUpFixtureAttribute"> + <summary> + Attribute used to mark a class that contains one-time SetUp + and/or TearDown methods that apply to all the tests in a + namespace or an assembly. + </summary> + </member> + <member name="T:NUnit.Framework.SuiteAttribute"> + <summary> + Attribute used to mark a static (shared in VB) property + that returns a list of tests. + </summary> + </member> + <member name="T:NUnit.Framework.TearDownAttribute"> + <summary> + Attribute used in a TestFixture to identify a method that is + called immediately after each test is run. It is also used + in a SetUpFixture to identify the method that is called once, + after all subordinate tests have run. In either case, the method + is guaranteed to be called, even if an exception is thrown. + </summary> + </member> + <member name="T:NUnit.Framework.TestActionAttribute"> + <summary> + Provide actions to execute before and after tests. + </summary> + </member> + <member name="T:NUnit.Framework.ITestAction"> + <summary> + When implemented by an attribute, this interface implemented to provide actions to execute before and after tests. + </summary> + </member> + <member name="M:NUnit.Framework.ITestAction.BeforeTest(NUnit.Framework.TestDetails)"> + <summary> + Executed before each test is run + </summary> + <param name="testDetails">Provides details about the test that is going to be run.</param> + </member> + <member name="M:NUnit.Framework.ITestAction.AfterTest(NUnit.Framework.TestDetails)"> + <summary> + Executed after each test is run + </summary> + <param name="testDetails">Provides details about the test that has just been run.</param> + </member> + <member name="P:NUnit.Framework.ITestAction.Targets"> + <summary> + Provides the target for the action attribute + </summary> + <returns>The target for the action attribute</returns> + </member> + <member name="T:NUnit.Framework.TestAttribute"> + <summary> + Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/> + class makes the method callable from the NUnit test runner. There is a property + called Description which is optional which you can provide a more detailed test + description. This class cannot be inherited. + </summary> + + <example> + [TestFixture] + public class Fixture + { + [Test] + public void MethodToTest() + {} + + [Test(Description = "more detailed description")] + publc void TestDescriptionMethod() + {} + } + </example> + + </member> + <member name="P:NUnit.Framework.TestAttribute.Description"> + <summary> + Descriptive text for this test + </summary> + </member> + <member name="T:NUnit.Framework.TestCaseAttribute"> + <summary> + TestCaseAttribute is used to mark parameterized test cases + and provide them with their arguments. + </summary> + </member> + <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object[])"> + <summary> + Construct a TestCaseAttribute with a list of arguments. + This constructor is not CLS-Compliant + </summary> + <param name="arguments"></param> + </member> + <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object)"> + <summary> + Construct a TestCaseAttribute with a single argument + </summary> + <param name="arg"></param> + </member> + <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object)"> + <summary> + Construct a TestCaseAttribute with a two arguments + </summary> + <param name="arg1"></param> + <param name="arg2"></param> + </member> + <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object,System.Object)"> + <summary> + Construct a TestCaseAttribute with a three arguments + </summary> + <param name="arg1"></param> + <param name="arg2"></param> + <param name="arg3"></param> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Arguments"> + <summary> + Gets the list of arguments to a test case + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Result"> + <summary> + Gets or sets the expected result. Use + ExpectedResult by preference. + </summary> + <value>The result.</value> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedResult"> + <summary> + Gets or sets the expected result. + </summary> + <value>The result.</value> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.HasExpectedResult"> + <summary> + Gets a flag indicating whether an expected + result has been set. + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Categories"> + <summary> + Gets a list of categories associated with this test; + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Category"> + <summary> + Gets or sets the category associated with this test. + May be a single category or a comma-separated list. + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedException"> + <summary> + Gets or sets the expected exception. + </summary> + <value>The expected exception.</value> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedExceptionName"> + <summary> + Gets or sets the name the expected exception. + </summary> + <value>The expected name of the exception.</value> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedMessage"> + <summary> + Gets or sets the expected message of the expected exception + </summary> + <value>The expected message of the exception.</value> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.MatchType"> + <summary> + Gets or sets the type of match to be performed on the expected message + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Description"> + <summary> + Gets or sets the description. + </summary> + <value>The description.</value> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.TestName"> + <summary> + Gets or sets the name of the test. + </summary> + <value>The name of the test.</value> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Ignore"> + <summary> + Gets or sets the ignored status of the test + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Ignored"> + <summary> + Gets or sets the ignored status of the test + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Explicit"> + <summary> + Gets or sets the explicit status of the test + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.Reason"> + <summary> + Gets or sets the reason for not running the test + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseAttribute.IgnoreReason"> + <summary> + Gets or sets the reason for not running the test. + Set has the side effect of marking the test as ignored. + </summary> + <value>The ignore reason.</value> + </member> + <member name="T:NUnit.Framework.TestCaseSourceAttribute"> + <summary> + FactoryAttribute indicates the source to be used to + provide test cases for a test method. + </summary> + </member> + <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.String)"> + <summary> + Construct with the name of the data source, which must + be a property, field or method of the test class itself. + </summary> + <param name="sourceName">An array of the names of the factories that will provide data</param> + </member> + <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.Type)"> + <summary> + Construct with a Type, which must implement IEnumerable + </summary> + <param name="sourceType">The Type that will provide data</param> + </member> + <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.Type,System.String)"> + <summary> + Construct with a Type and name. + that don't support params arrays. + </summary> + <param name="sourceType">The Type that will provide data</param> + <param name="sourceName">The name of the method, property or field that will provide data</param> + </member> + <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceName"> + <summary> + The name of a the method, property or fiend to be used as a source + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceType"> + <summary> + A Type to be used as a source + </summary> + </member> + <member name="P:NUnit.Framework.TestCaseSourceAttribute.Category"> + <summary> + Gets or sets the category associated with this test. + May be a single category or a comma-separated list. + </summary> + </member> + <member name="T:NUnit.Framework.TestFixtureAttribute"> + <example> + [TestFixture] + public class ExampleClass + {} + </example> + </member> + <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor"> + <summary> + Default constructor + </summary> + </member> + <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor(System.Object[])"> + <summary> + Construct with a object[] representing a set of arguments. + In .NET 2.0, the arguments may later be separated into + type arguments and constructor arguments. + </summary> + <param name="arguments"></param> + </member> + <member name="P:NUnit.Framework.TestFixtureAttribute.Description"> + <summary> + Descriptive text for this fixture + </summary> + </member> + <member name="P:NUnit.Framework.TestFixtureAttribute.Category"> + <summary> + Gets and sets the category for this fixture. + May be a comma-separated list of categories. + </summary> + </member> + <member name="P:NUnit.Framework.TestFixtureAttribute.Categories"> + <summary> + Gets a list of categories for this fixture + </summary> + </member> + <member name="P:NUnit.Framework.TestFixtureAttribute.Arguments"> + <summary> + The arguments originally provided to the attribute + </summary> + </member> + <member name="P:NUnit.Framework.TestFixtureAttribute.Ignore"> + <summary> + Gets or sets a value indicating whether this <see cref="T:NUnit.Framework.TestFixtureAttribute"/> should be ignored. + </summary> + <value><c>true</c> if ignore; otherwise, <c>false</c>.</value> + </member> + <member name="P:NUnit.Framework.TestFixtureAttribute.IgnoreReason"> + <summary> + Gets or sets the ignore reason. May set Ignored as a side effect. + </summary> + <value>The ignore reason.</value> + </member> + <member name="P:NUnit.Framework.TestFixtureAttribute.TypeArgs"> + <summary> + Get or set the type arguments. If not set + explicitly, any leading arguments that are + Types are taken as type arguments. + </summary> + </member> + <member name="T:NUnit.Framework.TestFixtureSetUpAttribute"> + <summary> + Attribute used to identify a method that is + called before any tests in a fixture are run. + </summary> + </member> + <member name="T:NUnit.Framework.TestFixtureTearDownAttribute"> + <summary> + Attribute used to identify a method that is called after + all the tests in a fixture have run. The method is + guaranteed to be called, even if an exception is thrown. + </summary> + </member> + <member name="T:NUnit.Framework.TheoryAttribute"> + <summary> + Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/> + class makes the method callable from the NUnit test runner. There is a property + called Description which is optional which you can provide a more detailed test + description. This class cannot be inherited. + </summary> + + <example> + [TestFixture] + public class Fixture + { + [Test] + public void MethodToTest() + {} + + [Test(Description = "more detailed description")] + publc void TestDescriptionMethod() + {} + } + </example> + + </member> + <member name="T:NUnit.Framework.TimeoutAttribute"> + <summary> + Used on a method, marks the test with a timeout value in milliseconds. + The test will be run in a separate thread and is cancelled if the timeout + is exceeded. Used on a method or assembly, sets the default timeout + for all contained test methods. + </summary> + </member> + <member name="M:NUnit.Framework.TimeoutAttribute.#ctor(System.Int32)"> + <summary> + Construct a TimeoutAttribute given a time in milliseconds + </summary> + <param name="timeout">The timeout value in milliseconds</param> + </member> + <member name="T:NUnit.Framework.RequiresSTAAttribute"> + <summary> + Marks a test that must run in the STA, causing it + to run in a separate thread if necessary. + + On methods, you may also use STAThreadAttribute + to serve the same purpose. + </summary> + </member> + <member name="M:NUnit.Framework.RequiresSTAAttribute.#ctor"> + <summary> + Construct a RequiresSTAAttribute + </summary> + </member> + <member name="T:NUnit.Framework.RequiresMTAAttribute"> + <summary> + Marks a test that must run in the MTA, causing it + to run in a separate thread if necessary. + + On methods, you may also use MTAThreadAttribute + to serve the same purpose. + </summary> + </member> + <member name="M:NUnit.Framework.RequiresMTAAttribute.#ctor"> + <summary> + Construct a RequiresMTAAttribute + </summary> + </member> + <member name="T:NUnit.Framework.RequiresThreadAttribute"> + <summary> + Marks a test that must run on a separate thread. + </summary> + </member> + <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor"> + <summary> + Construct a RequiresThreadAttribute + </summary> + </member> + <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor(System.Threading.ApartmentState)"> + <summary> + Construct a RequiresThreadAttribute, specifying the apartment + </summary> + </member> + <member name="T:NUnit.Framework.ValueSourceAttribute"> + <summary> + ValueSourceAttribute indicates the source to be used to + provide data for one parameter of a test method. + </summary> + </member> + <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.String)"> + <summary> + Construct with the name of the factory - for use with languages + that don't support params arrays. + </summary> + <param name="sourceName">The name of the data source to be used</param> + </member> + <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.Type,System.String)"> + <summary> + Construct with a Type and name - for use with languages + that don't support params arrays. + </summary> + <param name="sourceType">The Type that will provide data</param> + <param name="sourceName">The name of the method, property or field that will provide data</param> + </member> + <member name="P:NUnit.Framework.ValueSourceAttribute.SourceName"> + <summary> + The name of a the method, property or fiend to be used as a source + </summary> + </member> + <member name="P:NUnit.Framework.ValueSourceAttribute.SourceType"> + <summary> + A Type to be used as a source + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.AllItemsConstraint"> + <summary> + AllItemsConstraint applies another constraint to each + item in a collection, succeeding if they all succeed. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.PrefixConstraint"> + <summary> + Abstract base class used for prefixes + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.Constraint"> + <summary> + The Constraint class is the base of all built-in constraints + within NUnit. It provides the operator overloads used to combine + constraints. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.IResolveConstraint"> + <summary> + The IConstraintExpression interface is implemented by all + complete and resolvable constraints and expressions. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.IResolveConstraint.Resolve"> + <summary> + Return the top-level constraint for this expression + </summary> + <returns></returns> + </member> + <member name="F:NUnit.Framework.Constraints.Constraint.UNSET"> + <summary> + Static UnsetObject used to detect derived constraints + failing to set the actual value. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.Constraint.actual"> + <summary> + The actual value being tested against a constraint + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.Constraint.displayName"> + <summary> + The display name of this Constraint for use by ToString() + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.Constraint.argcnt"> + <summary> + Argument fields used by ToString(); + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.Constraint.builder"> + <summary> + The builder holding this constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.#ctor"> + <summary> + Construct a constraint with no arguments + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object)"> + <summary> + Construct a constraint with one argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object,System.Object)"> + <summary> + Construct a constraint with two arguments + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.SetBuilder(NUnit.Framework.Constraints.ConstraintBuilder)"> + <summary> + Sets the ConstraintBuilder holding this constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the failure message to the MessageWriter provided + as an argument. The default implementation simply passes + the constraint and the actual value to the writer, which + then displays the constraint description and the value. + + Constraints that need to provide additional details, + such as where the error occured can override this. + </summary> + <param name="writer">The MessageWriter on which to display the message</param> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.Matches``1(NUnit.Framework.Constraints.ActualValueDelegate{``0})"> + <summary> + Test whether the constraint is satisfied by an + ActualValueDelegate that returns the value to be tested. + The default implementation simply evaluates the delegate + but derived classes may override it to provide for delayed + processing. + </summary> + <param name="del">An <see cref="T:NUnit.Framework.Constraints.ActualValueDelegate`1"/></param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.Matches``1(``0@)"> + <summary> + Test whether the constraint is satisfied by a given reference. + The default implementation simply dereferences the value but + derived classes may override it to provide for delayed processing. + </summary> + <param name="actual">A reference to the value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.ToString"> + <summary> + Default override of ToString returns the constraint DisplayName + followed by any arguments within angle brackets. + </summary> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.GetStringRepresentation"> + <summary> + Returns the string representation of this constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + This operator creates a constraint that is satisfied only if both + argument constraints are satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + This operator creates a constraint that is satisfied if either + of the argument constraints is satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.op_LogicalNot(NUnit.Framework.Constraints.Constraint)"> + <summary> + This operator creates a constraint that is satisfied if the + argument constraint is not satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32)"> + <summary> + Returns a DelayedConstraint with the specified delay time. + </summary> + <param name="delayInMilliseconds">The delay in milliseconds.</param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32,System.Int32)"> + <summary> + Returns a DelayedConstraint with the specified delay time + and polling interval. + </summary> + <param name="delayInMilliseconds">The delay in milliseconds.</param> + <param name="pollingInterval">The interval at which to test the constraint.</param> + <returns></returns> + </member> + <member name="P:NUnit.Framework.Constraints.Constraint.DisplayName"> + <summary> + The display name of this Constraint for use by ToString(). + The default value is the name of the constraint with + trailing "Constraint" removed. Derived classes may set + this to another name in their constructors. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Constraint.And"> + <summary> + Returns a ConstraintExpression by appending And + to the current constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Constraint.With"> + <summary> + Returns a ConstraintExpression by appending And + to the current constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Constraint.Or"> + <summary> + Returns a ConstraintExpression by appending Or + to the current constraint. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.Constraint.UnsetObject"> + <summary> + Class used to detect any derived constraints + that fail to set the actual value in their + Matches override. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.PrefixConstraint.baseConstraint"> + <summary> + The base constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PrefixConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Construct given a base constraint + </summary> + <param name="resolvable"></param> + </member> + <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)"> + <summary> + Construct an AllItemsConstraint on top of an existing constraint + </summary> + <param name="itemConstraint"></param> + </member> + <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.Matches(System.Object)"> + <summary> + Apply the item constraint to each item in the collection, + failing if any item fails. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.AndConstraint"> + <summary> + AndConstraint succeeds only if both members succeed. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.BinaryConstraint"> + <summary> + BinaryConstraint is the abstract base of all constraints + that combine two other constraints in some fashion. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.BinaryConstraint.left"> + <summary> + The first constraint being combined + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.BinaryConstraint.right"> + <summary> + The second constraint being combined + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.BinaryConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + Construct a BinaryConstraint from two other constraints + </summary> + <param name="left">The first constraint</param> + <param name="right">The second constraint</param> + </member> + <member name="M:NUnit.Framework.Constraints.AndConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + Create an AndConstraint from two other constraints + </summary> + <param name="left">The first constraint</param> + <param name="right">The second constraint</param> + </member> + <member name="M:NUnit.Framework.Constraints.AndConstraint.Matches(System.Object)"> + <summary> + Apply both member constraints to an actual value, succeeding + succeeding only if both of them succeed. + </summary> + <param name="actual">The actual value</param> + <returns>True if the constraints both succeeded</returns> + </member> + <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description for this contraint to a MessageWriter + </summary> + <param name="writer">The MessageWriter to receive the description</param> + </member> + <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.AssignableFromConstraint"> + <summary> + AssignableFromConstraint is used to test that an object + can be assigned from a given Type. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.TypeConstraint"> + <summary> + TypeConstraint is the abstract base for constraints + that take a Type as their expected value. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.TypeConstraint.expectedType"> + <summary> + The expected Type used by the constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.TypeConstraint.#ctor(System.Type)"> + <summary> + Construct a TypeConstraint for a given Type + </summary> + <param name="type"></param> + </member> + <member name="M:NUnit.Framework.Constraints.TypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. TypeConstraints override this method to write + the name of the type. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.#ctor(System.Type)"> + <summary> + Construct an AssignableFromConstraint for the type provided + </summary> + <param name="type"></param> + </member> + <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.Matches(System.Object)"> + <summary> + Test whether an object can be assigned from the specified type + </summary> + <param name="actual">The object to be tested</param> + <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer">The MessageWriter to use</param> + </member> + <member name="T:NUnit.Framework.Constraints.AssignableToConstraint"> + <summary> + AssignableToConstraint is used to test that an object + can be assigned to a given Type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.#ctor(System.Type)"> + <summary> + Construct an AssignableToConstraint for the type provided + </summary> + <param name="type"></param> + </member> + <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.Matches(System.Object)"> + <summary> + Test whether an object can be assigned to the specified type + </summary> + <param name="actual">The object to be tested</param> + <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer">The MessageWriter to use</param> + </member> + <member name="T:NUnit.Framework.Constraints.AttributeConstraint"> + <summary> + AttributeConstraint tests that a specified attribute is present + on a Type or other provider and that the value of the attribute + satisfies some other constraint. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeConstraint.#ctor(System.Type,NUnit.Framework.Constraints.Constraint)"> + <summary> + Constructs an AttributeConstraint for a specified attriute + Type and base constraint. + </summary> + <param name="type"></param> + <param name="baseConstraint"></param> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeConstraint.Matches(System.Object)"> + <summary> + Determines whether the Type or other provider has the + expected attribute and if its value matches the + additional constraint specified. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Writes a description of the attribute to the specified writer. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Writes the actual value supplied to the specified writer. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeConstraint.GetStringRepresentation"> + <summary> + Returns a string representation of the constraint. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.AttributeExistsConstraint"> + <summary> + AttributeExistsConstraint tests for the presence of a + specified attribute on a Type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.#ctor(System.Type)"> + <summary> + Constructs an AttributeExistsConstraint for a specific attribute Type + </summary> + <param name="type"></param> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.Matches(System.Object)"> + <summary> + Tests whether the object provides the expected attribute. + </summary> + <param name="actual">A Type, MethodInfo, or other ICustomAttributeProvider</param> + <returns>True if the expected attribute is present, otherwise false</returns> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Writes the description of the constraint to the specified writer + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.BasicConstraint"> + <summary> + BasicConstraint is the abstract base for constraints that + perform a simple comparison to a constant value. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.BasicConstraint.#ctor(System.Object,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:BasicConstraint"/> class. + </summary> + <param name="expected">The expected.</param> + <param name="description">The description.</param> + </member> + <member name="M:NUnit.Framework.Constraints.BasicConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.BasicConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.BinarySerializableConstraint"> + <summary> + BinarySerializableConstraint tests whether + an object is serializable in binary format. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.GetStringRepresentation"> + <summary> + Returns the string representation + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionConstraint"> + <summary> + CollectionConstraint is the abstract base class for + constraints that operate on collections. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor"> + <summary> + Construct an empty CollectionConstraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor(System.Object)"> + <summary> + Construct a CollectionConstraint + </summary> + <param name="arg"></param> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionConstraint.IsEmpty(System.Collections.IEnumerable)"> + <summary> + Determines whether the specified enumerable is empty. + </summary> + <param name="enumerable">The enumerable.</param> + <returns> + <c>true</c> if the specified enumerable is empty; otherwise, <c>false</c>. + </returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionConstraint.doMatch(System.Collections.IEnumerable)"> + <summary> + Protected method to be implemented by derived classes + </summary> + <param name="collection"></param> + <returns></returns> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionContainsConstraint"> + <summary> + CollectionContainsConstraint is used to test whether a collection + contains an expected object as a member. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint"> + <summary> + CollectionItemsEqualConstraint is the abstract base class for all + collection constraints that apply some notion of item equality + as a part of their operation. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor"> + <summary> + Construct an empty CollectionConstraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor(System.Object)"> + <summary> + Construct a CollectionConstraint + </summary> + <param name="arg"></param> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(NUnit.Framework.Constraints.EqualityAdapter)"> + <summary> + Flag the constraint to use the supplied EqualityAdapter. + NOTE: For internal use only. + </summary> + <param name="adapter">The EqualityAdapter to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IComparer)"> + <summary> + Flag the constraint to use the supplied IComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})"> + <summary> + Flag the constraint to use the supplied IComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Comparison{``0})"> + <summary> + Flag the constraint to use the supplied Comparison object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IEqualityComparer)"> + <summary> + Flag the constraint to use the supplied IEqualityComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})"> + <summary> + Flag the constraint to use the supplied IEqualityComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.ItemsEqual(System.Object,System.Object)"> + <summary> + Compares two collection members for equality + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Tally(System.Collections.IEnumerable)"> + <summary> + Return a new CollectionTally for use in making tests + </summary> + <param name="c">The collection to be included in the tally</param> + </member> + <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.IgnoreCase"> + <summary> + Flag the constraint to ignore case and return self. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.#ctor(System.Object)"> + <summary> + Construct a CollectionContainsConstraint + </summary> + <param name="expected"></param> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.doMatch(System.Collections.IEnumerable)"> + <summary> + Test whether the expected item is contained in the collection + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a descripton of the constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionEquivalentConstraint"> + <summary> + CollectionEquivalentCOnstraint is used to determine whether two + collections are equivalent. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.#ctor(System.Collections.IEnumerable)"> + <summary> + Construct a CollectionEquivalentConstraint + </summary> + <param name="expected"></param> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.doMatch(System.Collections.IEnumerable)"> + <summary> + Test whether two collections are equivalent + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionOrderedConstraint"> + <summary> + CollectionOrderedConstraint is used to test whether a collection is ordered. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.#ctor"> + <summary> + Construct a CollectionOrderedConstraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using(System.Collections.IComparer)"> + <summary> + Modifies the constraint to use an IComparer and returns self. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Collections.Generic.IComparer{``0})"> + <summary> + Modifies the constraint to use an IComparer<T> and returns self. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Comparison{``0})"> + <summary> + Modifies the constraint to use a Comparison<T> and returns self. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.By(System.String)"> + <summary> + Modifies the constraint to test ordering by the value of + a specified property and returns self. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.doMatch(System.Collections.IEnumerable)"> + <summary> + Test whether the collection is ordered + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of the constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.GetStringRepresentation"> + <summary> + Returns the string representation of the constraint. + </summary> + <returns></returns> + </member> + <member name="P:NUnit.Framework.Constraints.CollectionOrderedConstraint.Descending"> + <summary> + If used performs a reverse comparison + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionSubsetConstraint"> + <summary> + CollectionSubsetConstraint is used to determine whether + one collection is a subset of another + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.#ctor(System.Collections.IEnumerable)"> + <summary> + Construct a CollectionSubsetConstraint + </summary> + <param name="expected">The collection that the actual value is expected to be a subset of</param> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.doMatch(System.Collections.IEnumerable)"> + <summary> + Test whether the actual collection is a subset of + the expected collection provided. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionTally"> + <summary> + CollectionTally counts (tallies) the number of + occurences of each object in one or more enumerations. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionTally.#ctor(NUnit.Framework.Constraints.NUnitEqualityComparer,System.Collections.IEnumerable)"> + <summary> + Construct a CollectionTally object from a comparer and a collection + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionTally.TryRemove(System.Object)"> + <summary> + Try to remove an object from the tally + </summary> + <param name="o">The object to remove</param> + <returns>True if successful, false if the object was not found</returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionTally.TryRemove(System.Collections.IEnumerable)"> + <summary> + Try to remove a set of objects from the tally + </summary> + <param name="c">The objects to remove</param> + <returns>True if successful, false if any object was not found</returns> + </member> + <member name="P:NUnit.Framework.Constraints.CollectionTally.Count"> + <summary> + The number of objects remaining in the tally + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ComparisonAdapter"> + <summary> + ComparisonAdapter class centralizes all comparisons of + values in NUnit, adapting to the use of any provided + IComparer, IComparer<T> or Comparison<T> + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For(System.Collections.IComparer)"> + <summary> + Returns a ComparisonAdapter that wraps an IComparer + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Collections.Generic.IComparer{``0})"> + <summary> + Returns a ComparisonAdapter that wraps an IComparer<T> + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Comparison{``0})"> + <summary> + Returns a ComparisonAdapter that wraps a Comparison<T> + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.Compare(System.Object,System.Object)"> + <summary> + Compares two objects + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ComparisonAdapter.Default"> + <summary> + Gets the default ComparisonAdapter, which wraps an + NUnitComparer object. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.#ctor(System.Collections.IComparer)"> + <summary> + Construct a ComparisonAdapter for an IComparer + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.Compare(System.Object,System.Object)"> + <summary> + Compares two objects + </summary> + <param name="expected"></param> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.DefaultComparisonAdapter.#ctor"> + <summary> + Construct a default ComparisonAdapter + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1"> + <summary> + ComparisonAdapter<T> extends ComparisonAdapter and + allows use of an IComparer<T> or Comparison<T> + to actually perform the comparison. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.#ctor(System.Collections.Generic.IComparer{`0})"> + <summary> + Construct a ComparisonAdapter for an IComparer<T> + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.Compare(System.Object,System.Object)"> + <summary> + Compare a Type T to an object + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.#ctor(System.Comparison{`0})"> + <summary> + Construct a ComparisonAdapter for a Comparison<T> + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.Compare(System.Object,System.Object)"> + <summary> + Compare a Type T to an object + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ComparisonConstraint"> + <summary> + Abstract base class for constraints that compare values to + determine if one is greater than, equal to or less than + the other. This class supplies the Using modifiers. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.comparer"> + <summary> + ComparisonAdapter to be used in making the comparison + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object,System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using(System.Collections.IComparer)"> + <summary> + Modifies the constraint to use an IComparer and returns self + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Collections.Generic.IComparer{``0})"> + <summary> + Modifies the constraint to use an IComparer<T> and returns self + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Comparison{``0})"> + <summary> + Modifies the constraint to use a Comparison<T> and returns self + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ActualValueDelegate`1"> + <summary> + Delegate used to delay evaluation of the actual value + to be used in evaluating a constraint + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ConstraintBuilder"> + <summary> + ConstraintBuilder maintains the stacks that are used in + processing a ConstraintExpression. An OperatorStack + is used to hold operators that are waiting for their + operands to be reognized. a ConstraintStack holds + input constraints as well as the results of each + operator applied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:ConstraintBuilder"/> class. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.ConstraintOperator)"> + <summary> + Appends the specified operator to the expression by first + reducing the operator stack and then pushing the new + operator on the stack. + </summary> + <param name="op">The operator to push.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.Constraint)"> + <summary> + Appends the specified constraint to the expresson by pushing + it on the constraint stack. + </summary> + <param name="constraint">The constraint to push.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.SetTopOperatorRightContext(System.Object)"> + <summary> + Sets the top operator right context. + </summary> + <param name="rightContext">The right context.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ReduceOperatorStack(System.Int32)"> + <summary> + Reduces the operator stack until the topmost item + precedence is greater than or equal to the target precedence. + </summary> + <param name="targetPrecedence">The target precedence.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Resolve"> + <summary> + Resolves this instance, returning a Constraint. If the builder + is not currently in a resolvable state, an exception is thrown. + </summary> + <returns>The resolved constraint</returns> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.IsResolvable"> + <summary> + Gets a value indicating whether this instance is resolvable. + </summary> + <value> + <c>true</c> if this instance is resolvable; otherwise, <c>false</c>. + </value> + </member> + <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack"> + <summary> + OperatorStack is a type-safe stack for holding ConstraintOperators + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)"> + <summary> + Initializes a new instance of the <see cref="T:OperatorStack"/> class. + </summary> + <param name="builder">The builder.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Push(NUnit.Framework.Constraints.ConstraintOperator)"> + <summary> + Pushes the specified operator onto the stack. + </summary> + <param name="op">The op.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Pop"> + <summary> + Pops the topmost operator from the stack. + </summary> + <returns></returns> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Empty"> + <summary> + Gets a value indicating whether this <see cref="T:OpStack"/> is empty. + </summary> + <value><c>true</c> if empty; otherwise, <c>false</c>.</value> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Top"> + <summary> + Gets the topmost operator without modifying the stack. + </summary> + <value>The top.</value> + </member> + <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack"> + <summary> + ConstraintStack is a type-safe stack for holding Constraints + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)"> + <summary> + Initializes a new instance of the <see cref="T:ConstraintStack"/> class. + </summary> + <param name="builder">The builder.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Push(NUnit.Framework.Constraints.Constraint)"> + <summary> + Pushes the specified constraint. As a side effect, + the constraint's builder field is set to the + ConstraintBuilder owning this stack. + </summary> + <param name="constraint">The constraint.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Pop"> + <summary> + Pops this topmost constrait from the stack. + As a side effect, the constraint's builder + field is set to null. + </summary> + <returns></returns> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Empty"> + <summary> + Gets a value indicating whether this <see cref="T:ConstraintStack"/> is empty. + </summary> + <value><c>true</c> if empty; otherwise, <c>false</c>.</value> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Top"> + <summary> + Gets the topmost constraint without modifying the stack. + </summary> + <value>The topmost constraint</value> + </member> + <member name="T:NUnit.Framework.Constraints.ConstraintExpression"> + <summary> + ConstraintExpression represents a compound constraint in the + process of being constructed from a series of syntactic elements. + + Individual elements are appended to the expression as they are + reognized. Once an actual Constraint is appended, the expression + returns a resolvable Constraint. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ConstraintExpressionBase"> + <summary> + ConstraintExpressionBase is the abstract base class for the + ConstraintExpression class, which represents a + compound constraint in the process of being constructed + from a series of syntactic elements. + + NOTE: ConstraintExpressionBase is separate because the + ConstraintExpression class was generated in earlier + versions of NUnit. The two classes may be combined + in a future version. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ConstraintExpressionBase.builder"> + <summary> + The ConstraintBuilder holding the elements recognized so far + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> class. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)"> + <summary> + Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> + class passing in a ConstraintBuilder, which may be pre-populated. + </summary> + <param name="builder">The builder.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.ToString"> + <summary> + Returns a string representation of the expression as it + currently stands. This should only be used for testing, + since it has the side-effect of resolving the expression. + </summary> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.ConstraintOperator)"> + <summary> + Appends an operator to the expression and returns the + resulting expression itself. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.SelfResolvingOperator)"> + <summary> + Appends a self-resolving operator to the expression and + returns a new ResolvableConstraintExpression. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.Constraint)"> + <summary> + Appends a constraint to the expression and returns that + constraint, which is associated with the current state + of the expression being built. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:ConstraintExpression"/> class. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)"> + <summary> + Initializes a new instance of the <see cref="T:ConstraintExpression"/> + class passing in a ConstraintBuilder, which may be pre-populated. + </summary> + <param name="builder">The builder.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Exactly(System.Int32)"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding only if a specified number of them succeed. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Property(System.String)"> + <summary> + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute(System.Type)"> + <summary> + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute``1"> + <summary> + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns the constraint provided as an argument - used to allow custom + custom constraints to easily participate in the syntax. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches``1(System.Predicate{``0})"> + <summary> + Returns the constraint provided as an argument - used to allow custom + custom constraints to easily participate in the syntax. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EqualTo(System.Object)"> + <summary> + Returns a constraint that tests two items for equality + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SameAs(System.Object)"> + <summary> + Returns a constraint that tests that two references are the same object + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThan(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThanOrEqualTo(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtLeast(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThan(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThanOrEqualTo(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtMost(System.Object)"> + <summary> + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf(System.Type)"> + <summary> + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf``1"> + <summary> + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf``1"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType``1"> + <summary> + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom``1"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo(System.Type)"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo``1"> + <summary> + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EquivalentTo(System.Collections.IEnumerable)"> + <summary> + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubsetOf(System.Collections.IEnumerable)"> + <summary> + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Member(System.Object)"> + <summary> + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.Object)"> + <summary> + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.String)"> + <summary> + Returns a new ContainsConstraint. This constraint + will, in turn, make use of the appropriate second-level + constraint, depending on the type of the actual argument. + This overload is only used if the item sought is a string, + since any other type implies that we are looking for a + collection member. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringContaining(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.ContainsSubstring(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StartsWith(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringStarting(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EndsWith(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringEnding(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value matches the regular expression supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringMatching(System.String)"> + <summary> + Returns a constraint that succeeds if the actual + value matches the regular expression supplied as an argument. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePath(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubPath(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePathOrUnder(System.String)"> + <summary> + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InRange``1(``0,``0)"> + <summary> + Returns a constraint that tests whether the actual value falls + within a specified range. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Not"> + <summary> + Returns a ConstraintExpression that negates any + following constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.No"> + <summary> + Returns a ConstraintExpression that negates any + following constraint. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.All"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Some"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.None"> + <summary> + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Length"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Count"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Message"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.InnerException"> + <summary> + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.With"> + <summary> + With is currently a NOP - reserved for future use. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Null"> + <summary> + Returns a constraint that tests for null + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.True"> + <summary> + Returns a constraint that tests for True + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.False"> + <summary> + Returns a constraint that tests for False + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Positive"> + <summary> + Returns a constraint that tests for a positive value + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Negative"> + <summary> + Returns a constraint that tests for a negative value + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.NaN"> + <summary> + Returns a constraint that tests for NaN + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Empty"> + <summary> + Returns a constraint that tests for empty + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Unique"> + <summary> + Returns a constraint that tests whether a collection + contains all unique items. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.BinarySerializable"> + <summary> + Returns a constraint that tests whether an object graph is serializable in binary format. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.XmlSerializable"> + <summary> + Returns a constraint that tests whether an object graph is serializable in xml format. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Ordered"> + <summary> + Returns a constraint that tests whether a collection is ordered + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ContainsConstraint"> + <summary> + ContainsConstraint tests a whether a string contains a substring + or a collection contains an object. It postpones the decision of + which test to use until the type of the actual argument is known. + This allows testing whether a string is contained in a collection + or as a substring of another string using the same syntax. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.ContainsConstraint"/> class. + </summary> + <param name="expected">The expected.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using(System.Collections.IComparer)"> + <summary> + Flag the constraint to use the supplied IComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Collections.Generic.IComparer{``0})"> + <summary> + Flag the constraint to use the supplied IComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Comparison{``0})"> + <summary> + Flag the constraint to use the supplied Comparison object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using(System.Collections.IEqualityComparer)"> + <summary> + Flag the constraint to use the supplied IEqualityComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})"> + <summary> + Flag the constraint to use the supplied IEqualityComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="P:NUnit.Framework.Constraints.ContainsConstraint.IgnoreCase"> + <summary> + Flag the constraint to ignore case and return self. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.DelayedConstraint"> + <summary> + Applies a delay to the match so that a match can be evaluated in the future. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32)"> + <summary> + Creates a new DelayedConstraint + </summary> + <param name="baseConstraint">The inner constraint two decorate</param> + <param name="delayInMilliseconds">The time interval after which the match is performed</param> + <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32,System.Int32)"> + <summary> + Creates a new DelayedConstraint + </summary> + <param name="baseConstraint">The inner constraint two decorate</param> + <param name="delayInMilliseconds">The time interval after which the match is performed</param> + <param name="pollingInterval">The time interval used for polling</param> + <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for if the base constraint fails, false if it succeeds</returns> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches``1(NUnit.Framework.Constraints.ActualValueDelegate{``0})"> + <summary> + Test whether the constraint is satisfied by a delegate + </summary> + <param name="del">The delegate whose value is to be tested</param> + <returns>True for if the base constraint fails, false if it succeeds</returns> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches``1(``0@)"> + <summary> + Test whether the constraint is satisfied by a given reference. + Overridden to wait for the specified delay period before + calling the base constraint with the dereferenced value. + </summary> + <param name="actual">A reference to the value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a MessageWriter. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.DelayedConstraint.GetStringRepresentation"> + <summary> + Returns the string representation of the constraint. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.EmptyCollectionConstraint"> + <summary> + EmptyCollectionConstraint tests whether a collection is empty. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.doMatch(System.Collections.IEnumerable)"> + <summary> + Check that the collection is empty + </summary> + <param name="collection"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.EmptyConstraint"> + <summary> + EmptyConstraint tests a whether a string or collection is empty, + postponing the decision about which test is applied until the + type of the actual argument is known. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.EmptyDirectoryConstraint"> + <summary> + EmptyDirectoryConstraint is used to test that a directory is empty + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyDirectoryConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyDirectoryConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyDirectoryConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.EmptyStringConstraint"> + <summary> + EmptyStringConstraint tests whether a string is empty. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.EndsWithConstraint"> + <summary> + EndsWithConstraint can test whether a string ends + with an expected substring. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.StringConstraint"> + <summary> + StringConstraint is the abstract base for constraints + that operate on strings. It supports the IgnoreCase + modifier for string operations. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.StringConstraint.expected"> + <summary> + The expected value + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.StringConstraint.caseInsensitive"> + <summary> + Indicates whether tests should be case-insensitive + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.StringConstraint.#ctor(System.String)"> + <summary> + Constructs a StringConstraint given an expected value + </summary> + <param name="expected">The expected value</param> + </member> + <member name="M:NUnit.Framework.Constraints.StringConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.StringConstraint.Matches(System.String)"> + <summary> + Test whether the constraint is satisfied by a given string + </summary> + <param name="actual">The string to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="P:NUnit.Framework.Constraints.StringConstraint.IgnoreCase"> + <summary> + Modify the constraint to ignore case in matching. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:EndsWithConstraint"/> class. + </summary> + <param name="expected">The expected string</param> + </member> + <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.Matches(System.String)"> + <summary> + Test whether the constraint is matched by the actual value. + This is a template method, which calls the IsMatch method + of the derived class. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.EqualConstraint"> + <summary> + EqualConstraint is able to compare an actual value with the + expected value provided in its constructor. Two objects are + considered equal if both are null, or if both have the same + value. NUnit has special semantics for some object types. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.EqualConstraint.clipStrings"> + <summary> + If true, strings in error messages will be clipped + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.EqualConstraint.comparer"> + <summary> + NUnitEqualityComparer used to test equality. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.EqualConstraint"/> class. + </summary> + <param name="expected">The expected value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Within(System.Object)"> + <summary> + Flag the constraint to use a tolerance when determining equality. + </summary> + <param name="amount">Tolerance value to be used</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Comparer(System.Collections.IComparer)"> + <summary> + Flag the constraint to use the supplied IComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IComparer)"> + <summary> + Flag the constraint to use the supplied IComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})"> + <summary> + Flag the constraint to use the supplied IComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Comparison{``0})"> + <summary> + Flag the constraint to use the supplied Comparison object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IEqualityComparer)"> + <summary> + Flag the constraint to use the supplied IEqualityComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})"> + <summary> + Flag the constraint to use the supplied IEqualityComparer object. + </summary> + <param name="comparer">The IComparer object to use.</param> + <returns>Self.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a failure message. Overridden to provide custom + failure messages for EqualConstraint. + </summary> + <param name="writer">The MessageWriter to write to</param> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write description of this constraint + </summary> + <param name="writer">The MessageWriter to write to</param> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)"> + <summary> + Display the failure information for two collections that did not match. + </summary> + <param name="writer">The MessageWriter on which to display</param> + <param name="expected">The expected collection.</param> + <param name="actual">The actual collection</param> + <param name="depth">The depth of this failure in a set of nested collections</param> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayTypesAndSizes(NUnit.Framework.Constraints.MessageWriter,System.Collections.IEnumerable,System.Collections.IEnumerable,System.Int32)"> + <summary> + Displays a single line showing the types and sizes of the expected + and actual enumerations, collections or arrays. If both are identical, + the value is only shown once. + </summary> + <param name="writer">The MessageWriter on which to display</param> + <param name="expected">The expected collection or array</param> + <param name="actual">The actual collection or array</param> + <param name="indent">The indentation level for the message line</param> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayFailurePoint(NUnit.Framework.Constraints.MessageWriter,System.Collections.IEnumerable,System.Collections.IEnumerable,NUnit.Framework.Constraints.FailurePoint,System.Int32)"> + <summary> + Displays a single line showing the point in the expected and actual + arrays at which the comparison failed. If the arrays have different + structures or dimensions, both values are shown. + </summary> + <param name="writer">The MessageWriter on which to display</param> + <param name="expected">The expected array</param> + <param name="actual">The actual array</param> + <param name="failurePoint">Index of the failure point in the underlying collections</param> + <param name="indent">The indentation level for the message line</param> + </member> + <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayEnumerableDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.IEnumerable,System.Collections.IEnumerable,System.Int32)"> + <summary> + Display the failure information for two IEnumerables that did not match. + </summary> + <param name="writer">The MessageWriter on which to display</param> + <param name="expected">The expected enumeration.</param> + <param name="actual">The actual enumeration</param> + <param name="depth">The depth of this failure in a set of nested collections</param> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.IgnoreCase"> + <summary> + Flag the constraint to ignore case and return self. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.NoClip"> + <summary> + Flag the constraint to suppress string clipping + and return self. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.AsCollection"> + <summary> + Flag the constraint to compare arrays as collections + and return self. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ulps"> + <summary> + Switches the .Within() modifier to interpret its tolerance as + a distance in representable values (see remarks). + </summary> + <returns>Self.</returns> + <remarks> + Ulp stands for "unit in the last place" and describes the minimum + amount a given value can change. For any integers, an ulp is 1 whole + digit. For floating point values, the accuracy of which is better + for smaller numbers and worse for larger numbers, an ulp depends + on the size of the number. Using ulps for comparison of floating + point results instead of fixed tolerances is safer because it will + automatically compensate for the added inaccuracy of larger numbers. + </remarks> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Percent"> + <summary> + Switches the .Within() modifier to interpret its tolerance as + a percentage that the actual values is allowed to deviate from + the expected value. + </summary> + <returns>Self</returns> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Days"> + <summary> + Causes the tolerance to be interpreted as a TimeSpan in days. + </summary> + <returns>Self</returns> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Hours"> + <summary> + Causes the tolerance to be interpreted as a TimeSpan in hours. + </summary> + <returns>Self</returns> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Minutes"> + <summary> + Causes the tolerance to be interpreted as a TimeSpan in minutes. + </summary> + <returns>Self</returns> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Seconds"> + <summary> + Causes the tolerance to be interpreted as a TimeSpan in seconds. + </summary> + <returns>Self</returns> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Milliseconds"> + <summary> + Causes the tolerance to be interpreted as a TimeSpan in milliseconds. + </summary> + <returns>Self</returns> + </member> + <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ticks"> + <summary> + Causes the tolerance to be interpreted as a TimeSpan in clock ticks. + </summary> + <returns>Self</returns> + </member> + <member name="T:NUnit.Framework.Constraints.EqualityAdapter"> + <summary> + EqualityAdapter class handles all equality comparisons + that use an IEqualityComparer, IEqualityComparer<T> + or a ComparisonAdapter. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.AreEqual(System.Object,System.Object)"> + <summary> + Compares two objects, returning true if they are equal + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.CanCompare(System.Object,System.Object)"> + <summary> + Returns true if the two objects can be compared by this adapter. + The base adapter cannot handle IEnumerables except for strings. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IComparer)"> + <summary> + Returns an EqualityAdapter that wraps an IComparer. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IEqualityComparer)"> + <summary> + Returns an EqualityAdapter that wraps an IEqualityComparer. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IEqualityComparer{``0})"> + <summary> + Returns an EqualityAdapter that wraps an IEqualityComparer<T>. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IComparer{``0})"> + <summary> + Returns an EqualityAdapter that wraps an IComparer<T>. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Comparison{``0})"> + <summary> + Returns an EqualityAdapter that wraps a Comparison<T>. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.EqualityAdapter.ComparerAdapter"> + <summary> + EqualityAdapter that wraps an IComparer. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.EqualityAdapter.GenericEqualityAdapter`1.CanCompare(System.Object,System.Object)"> + <summary> + Returns true if the two objects can be compared by this adapter. + Generic adapter requires objects of the specified type. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.EqualityAdapter.ComparerAdapter`1"> + <summary> + EqualityAdapter that wraps an IComparer. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.EqualityAdapterList"> + <summary> + EqualityAdapterList represents a list of EqualityAdapters + in a common class across platforms. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ExactCountConstraint"> + <summary> + ExactCountConstraint applies another constraint to each + item in a collection, succeeding only if a specified + number of items succeed. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ExactCountConstraint.#ctor(System.Int32,NUnit.Framework.Constraints.Constraint)"> + <summary> + Construct an ExactCountConstraint on top of an existing constraint + </summary> + <param name="expectedCount"></param> + <param name="itemConstraint"></param> + </member> + <member name="M:NUnit.Framework.Constraints.ExactCountConstraint.Matches(System.Object)"> + <summary> + Apply the item constraint to each item in the collection, + succeeding only if the expected number of items pass. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.ExactCountConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.ExactTypeConstraint"> + <summary> + ExactTypeConstraint is used to test that an object + is of the exact type provided in the constructor + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.#ctor(System.Type)"> + <summary> + Construct an ExactTypeConstraint for a given Type + </summary> + <param name="type">The expected Type.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.Matches(System.Object)"> + <summary> + Test that an object is of the exact type specified + </summary> + <param name="actual">The actual value.</param> + <returns>True if the tested object is of the exact type provided, otherwise false.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the description of this constraint to a MessageWriter + </summary> + <param name="writer">The MessageWriter to use</param> + </member> + <member name="T:NUnit.Framework.Constraints.ExceptionTypeConstraint"> + <summary> + ExceptionTypeConstraint is a special version of ExactTypeConstraint + used to provided detailed info about the exception thrown in + an error message. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ExceptionTypeConstraint.#ctor(System.Type)"> + <summary> + Constructs an ExceptionTypeConstraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ExceptionTypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. Overriden to write additional information + in the case of an Exception. + </summary> + <param name="writer">The MessageWriter to use</param> + </member> + <member name="T:NUnit.Framework.Constraints.FailurePoint"> + <summary> + FailurePoint class represents one point of failure + in an equality test. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.FailurePoint.Position"> + <summary> + The location of the failure + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.FailurePoint.ExpectedValue"> + <summary> + The expected value + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.FailurePoint.ActualValue"> + <summary> + The actual value + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.FailurePoint.ExpectedHasData"> + <summary> + Indicates whether the expected value is valid + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.FailurePoint.ActualHasData"> + <summary> + Indicates whether the actual value is valid + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.FailurePointList"> + <summary> + FailurePointList represents a set of FailurePoints + in a cross-platform way. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.FalseConstraint"> + <summary> + FalseConstraint tests that the actual value is false + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.FalseConstraint.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:FalseConstraint"/> class. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics"> + <summary>Helper routines for working with floating point numbers</summary> + <remarks> + <para> + The floating point comparison code is based on this excellent article: + http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm + </para> + <para> + "ULP" means Unit in the Last Place and in the context of this library refers to + the distance between two adjacent floating point numbers. IEEE floating point + numbers can only represent a finite subset of natural numbers, with greater + accuracy for smaller numbers and lower accuracy for very large numbers. + </para> + <para> + If a comparison is allowed "2 ulps" of deviation, that means the values are + allowed to deviate by up to 2 adjacent floating point values, which might be + as low as 0.0000001 for small numbers or as high as 10.0 for large numbers. + </para> + </remarks> + </member> + <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Single,System.Single,System.Int32)"> + <summary>Compares two floating point values for equality</summary> + <param name="left">First floating point value to be compared</param> + <param name="right">Second floating point value t be compared</param> + <param name="maxUlps"> + Maximum number of representable floating point values that are allowed to + be between the left and the right floating point values + </param> + <returns>True if both numbers are equal or close to being equal</returns> + <remarks> + <para> + Floating point values can only represent a finite subset of natural numbers. + For example, the values 2.00000000 and 2.00000024 can be stored in a float, + but nothing inbetween them. + </para> + <para> + This comparison will count how many possible floating point values are between + the left and the right number. If the number of possible values between both + numbers is less than or equal to maxUlps, then the numbers are considered as + being equal. + </para> + <para> + Implementation partially follows the code outlined here: + http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/ + </para> + </remarks> + </member> + <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Double,System.Double,System.Int64)"> + <summary>Compares two double precision floating point values for equality</summary> + <param name="left">First double precision floating point value to be compared</param> + <param name="right">Second double precision floating point value t be compared</param> + <param name="maxUlps"> + Maximum number of representable double precision floating point values that are + allowed to be between the left and the right double precision floating point values + </param> + <returns>True if both numbers are equal or close to being equal</returns> + <remarks> + <para> + Double precision floating point values can only represent a limited series of + natural numbers. For example, the values 2.0000000000000000 and 2.0000000000000004 + can be stored in a double, but nothing inbetween them. + </para> + <para> + This comparison will count how many possible double precision floating point + values are between the left and the right number. If the number of possible + values between both numbers is less than or equal to maxUlps, then the numbers + are considered as being equal. + </para> + <para> + Implementation partially follows the code outlined here: + http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/ + </para> + </remarks> + </member> + <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsInt(System.Single)"> + <summary> + Reinterprets the memory contents of a floating point value as an integer value + </summary> + <param name="value"> + Floating point value whose memory contents to reinterpret + </param> + <returns> + The memory contents of the floating point value interpreted as an integer + </returns> + </member> + <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsLong(System.Double)"> + <summary> + Reinterprets the memory contents of a double precision floating point + value as an integer value + </summary> + <param name="value"> + Double precision floating point value whose memory contents to reinterpret + </param> + <returns> + The memory contents of the double precision floating point value + interpreted as an integer + </returns> + </member> + <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsFloat(System.Int32)"> + <summary> + Reinterprets the memory contents of an integer as a floating point value + </summary> + <param name="value">Integer value whose memory contents to reinterpret</param> + <returns> + The memory contents of the integer value interpreted as a floating point value + </returns> + </member> + <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsDouble(System.Int64)"> + <summary> + Reinterprets the memory contents of an integer value as a double precision + floating point value + </summary> + <param name="value">Integer whose memory contents to reinterpret</param> + <returns> + The memory contents of the integer interpreted as a double precision + floating point value + </returns> + </member> + <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion"> + <summary>Union of a floating point variable and an integer</summary> + </member> + <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Float"> + <summary>The union's value as a floating point variable</summary> + </member> + <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Int"> + <summary>The union's value as an integer</summary> + </member> + <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.UInt"> + <summary>The union's value as an unsigned integer</summary> + </member> + <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion"> + <summary>Union of a double precision floating point variable and a long</summary> + </member> + <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Double"> + <summary>The union's value as a double precision floating point variable</summary> + </member> + <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Long"> + <summary>The union's value as a long</summary> + </member> + <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.ULong"> + <summary>The union's value as an unsigned long</summary> + </member> + <member name="T:NUnit.Framework.Constraints.GreaterThanConstraint"> + <summary> + Tests whether a value is greater than the value supplied to its constructor + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.GreaterThanConstraint.expected"> + <summary> + The value against which a comparison is to be made + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:GreaterThanConstraint"/> class. + </summary> + <param name="expected">The expected value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="T:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint"> + <summary> + Tests whether a value is greater than or equal to the value supplied to its constructor + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.expected"> + <summary> + The value against which a comparison is to be made + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:GreaterThanOrEqualConstraint"/> class. + </summary> + <param name="expected">The expected value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="T:NUnit.Framework.Constraints.InstanceOfTypeConstraint"> + <summary> + InstanceOfTypeConstraint is used to test that an object + is of the same type provided or derived from it. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.#ctor(System.Type)"> + <summary> + Construct an InstanceOfTypeConstraint for the type provided + </summary> + <param name="type">The expected Type</param> + </member> + <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.Matches(System.Object)"> + <summary> + Test whether an object is of the specified type or a derived type + </summary> + <param name="actual">The object to be tested</param> + <returns>True if the object is of the provided type or derives from it, otherwise false.</returns> + </member> + <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer">The MessageWriter to use</param> + </member> + <member name="T:NUnit.Framework.Constraints.LessThanConstraint"> + <summary> + Tests whether a value is less than the value supplied to its constructor + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.LessThanConstraint.expected"> + <summary> + The value against which a comparison is to be made + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.LessThanConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:LessThanConstraint"/> class. + </summary> + <param name="expected">The expected value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.LessThanConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.LessThanConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="T:NUnit.Framework.Constraints.LessThanOrEqualConstraint"> + <summary> + Tests whether a value is less than or equal to the value supplied to its constructor + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.LessThanOrEqualConstraint.expected"> + <summary> + The value against which a comparison is to be made + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:LessThanOrEqualConstraint"/> class. + </summary> + <param name="expected">The expected value.</param> + </member> + <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="T:NUnit.Framework.Constraints.MsgUtils"> + <summary> + Static methods used in creating messages + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.MsgUtils.ELLIPSIS"> + <summary> + Static string used when strings are clipped + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.MsgUtils.GetTypeRepresentation(System.Object)"> + <summary> + Returns the representation of a type as used in NUnitLite. + This is the same as Type.ToString() except for arrays, + which are displayed with their declared sizes. + </summary> + <param name="obj"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.MsgUtils.EscapeControlChars(System.String)"> + <summary> + Converts any control characters in a string + to their escaped representation. + </summary> + <param name="s">The string to be converted</param> + <returns>The converted string</returns> + </member> + <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesAsString(System.Int32[])"> + <summary> + Return the a string representation for a set of indices into an array + </summary> + <param name="indices">Array of indices for which a string is needed</param> + </member> + <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesFromCollectionIndex(System.Collections.IEnumerable,System.Int32)"> + <summary> + Get an array of indices representing the point in a enumerable, + collection or array corresponding to a single int index into the + collection. + </summary> + <param name="collection">The collection to which the indices apply</param> + <param name="index">Index in the collection</param> + <returns>Array of indices</returns> + </member> + <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipString(System.String,System.Int32,System.Int32)"> + <summary> + Clip a string to a given length, starting at a particular offset, returning the clipped + string with ellipses representing the removed parts + </summary> + <param name="s">The string to be clipped</param> + <param name="maxStringLength">The maximum permitted length of the result string</param> + <param name="clipStart">The point at which to start clipping</param> + <returns>The clipped string</returns> + </member> + <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipExpectedAndActual(System.String@,System.String@,System.Int32,System.Int32)"> + <summary> + Clip the expected and actual strings in a coordinated fashion, + so that they may be displayed together. + </summary> + <param name="expected"></param> + <param name="actual"></param> + <param name="maxDisplayLength"></param> + <param name="mismatch"></param> + </member> + <member name="M:NUnit.Framework.Constraints.MsgUtils.FindMismatchPosition(System.String,System.String,System.Int32,System.Boolean)"> + <summary> + Shows the position two strings start to differ. Comparison + starts at the start index. + </summary> + <param name="expected">The expected string</param> + <param name="actual">The actual string</param> + <param name="istart">The index in the strings at which comparison should start</param> + <param name="ignoreCase">Boolean indicating whether case should be ignored</param> + <returns>-1 if no mismatch found, or the index where mismatch found</returns> + </member> + <member name="T:NUnit.Framework.Constraints.NaNConstraint"> + <summary> + NaNConstraint tests that the actual value is a double or float NaN + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NaNConstraint.Matches(System.Object)"> + <summary> + Test that the actual value is an NaN + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.NaNConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a specified writer + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.NoItemConstraint"> + <summary> + NoItemConstraint applies another constraint to each + item in a collection, failing if any of them succeeds. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NoItemConstraint.#ctor(NUnit.Framework.Constraints.Constraint)"> + <summary> + Construct a NoItemConstraint on top of an existing constraint + </summary> + <param name="itemConstraint"></param> + </member> + <member name="M:NUnit.Framework.Constraints.NoItemConstraint.Matches(System.Object)"> + <summary> + Apply the item constraint to each item in the collection, + failing if any item fails. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.NoItemConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.NotConstraint"> + <summary> + NotConstraint negates the effect of some other constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NotConstraint.#ctor(NUnit.Framework.Constraints.Constraint)"> + <summary> + Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.NotConstraint"/> class. + </summary> + <param name="baseConstraint">The base constraint to be negated.</param> + </member> + <member name="M:NUnit.Framework.Constraints.NotConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for if the base constraint fails, false if it succeeds</returns> + </member> + <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a MessageWriter. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.NullConstraint"> + <summary> + NullConstraint tests that the actual value is null + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NullConstraint.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:NullConstraint"/> class. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.NullOrEmptyStringConstraint"> + <summary> + NullEmptyStringConstraint tests whether a string is either null or empty. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.#ctor"> + <summary> + Constructs a new NullOrEmptyStringConstraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.Numerics"> + <summary> + The Numerics class contains common operations on numeric values. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Numerics.IsNumericType(System.Object)"> + <summary> + Checks the type of the object, returning true if + the object is a numeric type. + </summary> + <param name="obj">The object to check</param> + <returns>true if the object is a numeric type</returns> + </member> + <member name="M:NUnit.Framework.Constraints.Numerics.IsFloatingPointNumeric(System.Object)"> + <summary> + Checks the type of the object, returning true if + the object is a floating point numeric type. + </summary> + <param name="obj">The object to check</param> + <returns>true if the object is a floating point numeric type</returns> + </member> + <member name="M:NUnit.Framework.Constraints.Numerics.IsFixedPointNumeric(System.Object)"> + <summary> + Checks the type of the object, returning true if + the object is a fixed point numeric type. + </summary> + <param name="obj">The object to check</param> + <returns>true if the object is a fixed point numeric type</returns> + </member> + <member name="M:NUnit.Framework.Constraints.Numerics.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)"> + <summary> + Test two numeric values for equality, performing the usual numeric + conversions and using a provided or default tolerance. If the tolerance + provided is Empty, this method may set it to a default tolerance. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <param name="tolerance">A reference to the tolerance in effect</param> + <returns>True if the values are equal</returns> + </member> + <member name="M:NUnit.Framework.Constraints.Numerics.Compare(System.Object,System.Object)"> + <summary> + Compare two numeric values, performing the usual numeric conversions. + </summary> + <param name="expected">The expected value</param> + <param name="actual">The actual value</param> + <returns>The relationship of the values to each other</returns> + </member> + <member name="T:NUnit.Framework.Constraints.NUnitComparer"> + <summary> + NUnitComparer encapsulates NUnit's default behavior + in comparing two objects. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NUnitComparer.Compare(System.Object,System.Object)"> + <summary> + Compares two objects + </summary> + <param name="x"></param> + <param name="y"></param> + <returns></returns> + </member> + <member name="P:NUnit.Framework.Constraints.NUnitComparer.Default"> + <summary> + Returns the default NUnitComparer. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.NUnitComparer`1"> + <summary> + Generic version of NUnitComparer + </summary> + <typeparam name="T"></typeparam> + </member> + <member name="M:NUnit.Framework.Constraints.NUnitComparer`1.Compare(`0,`0)"> + <summary> + Compare two objects of the same type + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer"> + <summary> + NUnitEqualityComparer encapsulates NUnit's handling of + equality tests between objects. + </summary> + </member> + <member name="T:NUnit.Framework.INUnitEqualityComparer"> + <summary> + + </summary> + </member> + <member name="M:NUnit.Framework.INUnitEqualityComparer.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)"> + <summary> + Compares two objects for equality within a tolerance + </summary> + <param name="x">The first object to compare</param> + <param name="y">The second object to compare</param> + <param name="tolerance">The tolerance to use in the comparison</param> + <returns></returns> + </member> + <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.caseInsensitive"> + <summary> + If true, all string comparisons will ignore case + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.compareAsCollection"> + <summary> + If true, arrays will be treated as collections, allowing + those of different dimensions to be compared + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.externalComparers"> + <summary> + Comparison objects used in comparisons for some constraints. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.failurePoints"> + <summary> + List of points at which a failure occured. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.recursionDetector"> + <summary> + RecursionDetector used to check for recursion when + evaluating self-referencing enumerables. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)"> + <summary> + Compares two objects for equality within a tolerance, setting + the tolerance to the actual tolerance used if an empty + tolerance is supplied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ArraysEqual(System.Array,System.Array,NUnit.Framework.Constraints.Tolerance@)"> + <summary> + Helper method to compare two arrays + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)"> + <summary> + Method to compare two DirectoryInfo objects + </summary> + <param name="expected">first directory to compare</param> + <param name="actual">second directory to compare</param> + <returns>true if equivalent, false if not</returns> + </member> + <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Default"> + <summary> + Returns the default NUnitEqualityComparer + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.IgnoreCase"> + <summary> + Gets and sets a flag indicating whether case should + be ignored in determining equality. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.CompareAsCollection"> + <summary> + Gets and sets a flag indicating that arrays should be + compared as collections, without regard to their shape. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.ExternalComparers"> + <summary> + Gets the list of external comparers to be used to + test for equality. They are applied to members of + collections, in place of NUnit's own logic. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.FailurePoints"> + <summary> + Gets the list of failure points for the last Match performed. + The list consists of objects to be interpreted by the caller. + This generally means that the caller may only make use of + objects it has placed on the list at a particular depthy. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer.RecursionDetector"> + <summary> + RecursionDetector detects when a comparison + between two enumerables has reached a point + where the same objects that were previously + compared are again being compared. This allows + the caller to stop the comparison if desired. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.RecursionDetector.CheckRecursion(System.Collections.IEnumerable,System.Collections.IEnumerable)"> + <summary> + Check whether two objects have previously + been compared, returning true if they have. + The two objects are remembered, so that a + second call will always return true. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.OrConstraint"> + <summary> + OrConstraint succeeds if either member succeeds + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.OrConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + Create an OrConstraint from two other constraints + </summary> + <param name="left">The first constraint</param> + <param name="right">The second constraint</param> + </member> + <member name="M:NUnit.Framework.Constraints.OrConstraint.Matches(System.Object)"> + <summary> + Apply the member constraints to an actual value, succeeding + succeeding as soon as one of them succeeds. + </summary> + <param name="actual">The actual value</param> + <returns>True if either constraint succeeded</returns> + </member> + <member name="M:NUnit.Framework.Constraints.OrConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description for this contraint to a MessageWriter + </summary> + <param name="writer">The MessageWriter to receive the description</param> + </member> + <member name="T:NUnit.Framework.Constraints.PathConstraint"> + <summary> + PathConstraint serves as the abstract base of constraints + that operate on paths and provides several helper methods. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.PathConstraint.expectedPath"> + <summary> + The expected path used in the constraint + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.PathConstraint.caseInsensitive"> + <summary> + Flag indicating whether a caseInsensitive comparison should be made + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PathConstraint.#ctor(System.String)"> + <summary> + Construct a PathConstraint for a give expected path + </summary> + <param name="expectedPath">The expected path</param> + </member> + <member name="M:NUnit.Framework.Constraints.PathConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.PathConstraint.IsMatch(System.String,System.String)"> + <summary> + Returns true if the expected path and actual path match + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PathConstraint.GetStringRepresentation"> + <summary> + Returns the string representation of this constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PathConstraint.Canonicalize(System.String)"> + <summary> + Transform the provided path to its canonical form so that it + may be more easily be compared with other paths. + </summary> + <param name="path">The original path</param> + <returns>The path in canonical form</returns> + </member> + <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSubPath(System.String,System.String,System.Boolean)"> + <summary> + Test whether one path in canonical form is under another. + </summary> + <param name="path1">The first path - supposed to be the parent path</param> + <param name="path2">The second path - supposed to be the child path</param> + <param name="ignoreCase">Indicates whether case should be ignored</param> + <returns></returns> + </member> + <member name="P:NUnit.Framework.Constraints.PathConstraint.IgnoreCase"> + <summary> + Modifies the current instance to be case-insensitve + and returns it. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.PathConstraint.RespectCase"> + <summary> + Modifies the current instance to be case-sensitve + and returns it. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.PredicateConstraint`1"> + <summary> + Predicate constraint wraps a Predicate in a constraint, + returning success if the predicate is true. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.#ctor(System.Predicate{`0})"> + <summary> + Construct a PredicateConstraint from a predicate + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.Matches(System.Object)"> + <summary> + Determines whether the predicate succeeds when applied + to the actual value. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Writes the description to a MessageWriter + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.PropertyConstraint"> + <summary> + PropertyConstraint extracts a named property and uses + its value as the actual value for a chained constraint. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyConstraint.#ctor(System.String,NUnit.Framework.Constraints.Constraint)"> + <summary> + Initializes a new instance of the <see cref="T:PropertyConstraint"/> class. + </summary> + <param name="name">The name.</param> + <param name="baseConstraint">The constraint to apply to the property.</param> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyConstraint.GetStringRepresentation"> + <summary> + Returns the string representation of the constraint. + </summary> + <returns></returns> + </member> + <member name="T:NUnit.Framework.Constraints.PropertyExistsConstraint"> + <summary> + PropertyExistsConstraint tests that a named property + exists on the object provided through Match. + + Originally, PropertyConstraint provided this feature + in addition to making optional tests on the vaue + of the property. The two constraints are now separate. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:PropertyExistConstraint"/> class. + </summary> + <param name="name">The name of the property.</param> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.Matches(System.Object)"> + <summary> + Test whether the property exists for a given object + </summary> + <param name="actual">The object to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.GetStringRepresentation"> + <summary> + Returns the string representation of the constraint. + </summary> + <returns></returns> + </member> + <member name="T:NUnit.Framework.Constraints.RangeConstraint`1"> + <summary> + RangeConstraint tests whether two values are within a + specified range. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.RangeConstraint`1.#ctor(`0,`0)"> + <summary> + Initializes a new instance of the <see cref="T:RangeConstraint"/> class. + </summary> + <param name="from">From.</param> + <param name="to">To.</param> + </member> + <member name="M:NUnit.Framework.Constraints.RangeConstraint`1.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.RangeConstraint`1.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.RegexConstraint"> + <summary> + RegexConstraint can test whether a string matches + the pattern provided. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.RegexConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:RegexConstraint"/> class. + </summary> + <param name="pattern">The pattern.</param> + </member> + <member name="M:NUnit.Framework.Constraints.RegexConstraint.Matches(System.String)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.RegexConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.ResolvableConstraintExpression"> + <summary> + ResolvableConstraintExpression is used to represent a compound + constraint being constructed at a point where the last operator + may either terminate the expression or may have additional + qualifying constraints added to it. + + It is used, for example, for a Property element or for + an Exception element, either of which may be optionally + followed by constraints that apply to the property or + exception. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor"> + <summary> + Create a new instance of ResolvableConstraintExpression + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)"> + <summary> + Create a new instance of ResolvableConstraintExpression, + passing in a pre-populated ConstraintBuilder. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.NUnit#Framework#Constraints#IResolveConstraint#Resolve"> + <summary> + Resolve the current expression to a Constraint + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseAnd(NUnit.Framework.Constraints.ResolvableConstraintExpression,NUnit.Framework.Constraints.ResolvableConstraintExpression)"> + <summary> + This operator creates a constraint that is satisfied only if both + argument constraints are satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.ResolvableConstraintExpression)"> + <summary> + This operator creates a constraint that is satisfied only if both + argument constraints are satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseAnd(NUnit.Framework.Constraints.ResolvableConstraintExpression,NUnit.Framework.Constraints.Constraint)"> + <summary> + This operator creates a constraint that is satisfied only if both + argument constraints are satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseOr(NUnit.Framework.Constraints.ResolvableConstraintExpression,NUnit.Framework.Constraints.ResolvableConstraintExpression)"> + <summary> + This operator creates a constraint that is satisfied if either + of the argument constraints is satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseOr(NUnit.Framework.Constraints.ResolvableConstraintExpression,NUnit.Framework.Constraints.Constraint)"> + <summary> + This operator creates a constraint that is satisfied if either + of the argument constraints is satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.ResolvableConstraintExpression)"> + <summary> + This operator creates a constraint that is satisfied if either + of the argument constraints is satisfied. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_LogicalNot(NUnit.Framework.Constraints.ResolvableConstraintExpression)"> + <summary> + This operator creates a constraint that is satisfied if the + argument constraint is not satisfied. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.And"> + <summary> + Appends an And Operator to the expression + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.Or"> + <summary> + Appends an Or operator to the expression. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ReusableConstraint"> + <summary> + ReusableConstraint wraps a constraint expression after + resolving it so that it can be reused consistently. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ReusableConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)"> + <summary> + Construct a ReusableConstraint from a constraint expression + </summary> + <param name="c">The expression to be resolved and reused</param> + </member> + <member name="M:NUnit.Framework.Constraints.ReusableConstraint.op_Implicit(NUnit.Framework.Constraints.Constraint)~NUnit.Framework.Constraints.ReusableConstraint"> + <summary> + Converts a constraint to a ReusableConstraint + </summary> + <param name="c">The constraint to be converted</param> + <returns>A ReusableConstraint</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ReusableConstraint.ToString"> + <summary> + Returns the string representation of the constraint. + </summary> + <returns>A string representing the constraint</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ReusableConstraint.Resolve"> + <summary> + Resolves the ReusableConstraint by returning the constraint + that it originally wrapped. + </summary> + <returns>A resolved constraint</returns> + </member> + <member name="T:NUnit.Framework.Constraints.SameAsConstraint"> + <summary> + SameAsConstraint tests whether an object is identical to + the object passed to its constructor + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.SameAsConstraint.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:SameAsConstraint"/> class. + </summary> + <param name="expected">The expected object.</param> + </member> + <member name="M:NUnit.Framework.Constraints.SameAsConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.SameAsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.SamePathConstraint"> + <summary> + Summary description for SamePathConstraint. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.SamePathConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:SamePathConstraint"/> class. + </summary> + <param name="expected">The expected path</param> + </member> + <member name="M:NUnit.Framework.Constraints.SamePathConstraint.IsMatch(System.String,System.String)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="expectedPath">The expected path</param> + <param name="actualPath">The actual path</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.SamePathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.SamePathOrUnderConstraint"> + <summary> + SamePathOrUnderConstraint tests that one path is under another + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:SamePathOrUnderConstraint"/> class. + </summary> + <param name="expected">The expected path</param> + </member> + <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.IsMatch(System.String,System.String)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="expectedPath">The expected path</param> + <param name="actualPath">The actual path</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.SomeItemsConstraint"> + <summary> + SomeItemsConstraint applies another constraint to each + item in a collection, succeeding if any of them succeeds. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)"> + <summary> + Construct a SomeItemsConstraint on top of an existing constraint + </summary> + <param name="itemConstraint"></param> + </member> + <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.Matches(System.Object)"> + <summary> + Apply the item constraint to each item in the collection, + succeeding if any item succeeds. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.StartsWithConstraint"> + <summary> + StartsWithConstraint can test whether a string starts + with an expected substring. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:StartsWithConstraint"/> class. + </summary> + <param name="expected">The expected string</param> + </member> + <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.Matches(System.String)"> + <summary> + Test whether the constraint is matched by the actual value. + This is a template method, which calls the IsMatch method + of the derived class. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.SubPathConstraint"> + <summary> + SubPathConstraint tests that the actual path is under the expected path + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.SubPathConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:SubPathConstraint"/> class. + </summary> + <param name="expected">The expected path</param> + </member> + <member name="M:NUnit.Framework.Constraints.SubPathConstraint.IsMatch(System.String,System.String)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="expectedPath">The expected path</param> + <param name="actualPath">The actual path</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.SubPathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.SubstringConstraint"> + <summary> + SubstringConstraint can test whether a string contains + the expected substring. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.SubstringConstraint.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:SubstringConstraint"/> class. + </summary> + <param name="expected">The expected.</param> + </member> + <member name="M:NUnit.Framework.Constraints.SubstringConstraint.Matches(System.String)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.SubstringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.ThrowsConstraint"> + <summary> + ThrowsConstraint is used to test the exception thrown by + a delegate by applying a constraint to it. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)"> + <summary> + Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.ThrowsConstraint"/> class, + using a constraint to be applied to the exception. + </summary> + <param name="baseConstraint">A constraint to apply to the caught exception.</param> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(System.Object)"> + <summary> + Executes the code of the delegate and captures any exception. + If a non-null base constraint was provided, it applies that + constraint to the exception. + </summary> + <param name="actual">A delegate representing the code to be tested</param> + <returns>True if an exception is thrown and the constraint succeeds, otherwise false</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches``1(NUnit.Framework.Constraints.ActualValueDelegate{``0})"> + <summary> + Converts an ActualValueDelegate to a TestDelegate + before calling the primary overload. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.GetStringRepresentation"> + <summary> + Returns the string representation of this constraint + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ThrowsConstraint.ActualException"> + <summary> + Get the actual exception thrown - used by Assert.Throws. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ThrowsNothingConstraint"> + <summary> + ThrowsNothingConstraint tests that a delegate does not + throw an exception. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True if no exception is thrown, otherwise false</returns> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. Overridden in ThrowsNothingConstraint to write + information about the exception that was actually caught. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="T:NUnit.Framework.Constraints.Tolerance"> + <summary> + The Tolerance class generalizes the notion of a tolerance + within which an equality test succeeds. Normally, it is + used with numeric types, but it can be used with any + type that supports taking a difference between two + objects and comparing that difference to a value. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object)"> + <summary> + Constructs a linear tolerance of a specdified amount + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object,NUnit.Framework.Constraints.ToleranceMode)"> + <summary> + Constructs a tolerance given an amount and ToleranceMode + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.Tolerance.CheckLinearAndNumeric"> + <summary> + Tests that the current Tolerance is linear with a + numeric value, throwing an exception if it is not. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Empty"> + <summary> + Returns an empty Tolerance object, equivalent to + specifying no tolerance. In most cases, it results + in an exact match but for floats and doubles a + default tolerance may be used. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Zero"> + <summary> + Returns a zero Tolerance object, equivalent to + specifying an exact match. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Mode"> + <summary> + Gets the ToleranceMode for the current Tolerance + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Value"> + <summary> + Gets the value of the current Tolerance instance. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Percent"> + <summary> + Returns a new tolerance, using the current amount as a percentage. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Ulps"> + <summary> + Returns a new tolerance, using the current amount in Ulps. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Days"> + <summary> + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of days. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Hours"> + <summary> + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of hours. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Minutes"> + <summary> + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of minutes. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Seconds"> + <summary> + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of seconds. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Milliseconds"> + <summary> + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of milliseconds. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.Ticks"> + <summary> + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of clock ticks. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.Tolerance.IsEmpty"> + <summary> + Returns true if the current tolerance is empty. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ToleranceMode"> + <summary> + Modes in which the tolerance value for a comparison can be interpreted. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ToleranceMode.None"> + <summary> + The tolerance was created with a value, without specifying + how the value would be used. This is used to prevent setting + the mode more than once and is generally changed to Linear + upon execution of the test. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ToleranceMode.Linear"> + <summary> + The tolerance is used as a numeric range within which + two compared values are considered to be equal. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ToleranceMode.Percent"> + <summary> + Interprets the tolerance as the percentage by which + the two compared values my deviate from each other. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ToleranceMode.Ulps"> + <summary> + Compares two values based in their distance in + representable numbers. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.TrueConstraint"> + <summary> + TrueConstraint tests that the actual value is true + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.TrueConstraint.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:TrueConstraint"/> class. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.UniqueItemsConstraint"> + <summary> + UniqueItemsConstraint tests whether all the items in a + collection are unique. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.doMatch(System.Collections.IEnumerable)"> + <summary> + Check that all items are unique. + </summary> + <param name="actual"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write a description of this constraint to a MessageWriter + </summary> + <param name="writer"></param> + </member> + <member name="T:NUnit.Framework.Constraints.XmlSerializableConstraint"> + <summary> + XmlSerializableConstraint tests whether + an object is serializable in XML format. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.Matches(System.Object)"> + <summary> + Test whether the constraint is satisfied by a given value + </summary> + <param name="actual">The value to be tested</param> + <returns>True for success, false for failure</returns> + </member> + <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the constraint description to a MessageWriter + </summary> + <param name="writer">The writer on which the description is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)"> + <summary> + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + </summary> + <param name="writer">The writer on which the actual value is displayed</param> + </member> + <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.GetStringRepresentation"> + <summary> + Returns the string representation of this constraint + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.AllOperator"> + <summary> + Represents a constraint that succeeds if all the + members of a collection match a base constraint. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.CollectionOperator"> + <summary> + Abstract base for operators that indicate how to + apply a constraint to items in a collection. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.PrefixOperator"> + <summary> + PrefixOperator takes a single constraint and modifies + it's action in some way. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ConstraintOperator"> + <summary> + The ConstraintOperator class is used internally by a + ConstraintBuilder to represent an operator that + modifies or combines constraints. + + Constraint operators use left and right precedence + values to determine whether the top operator on the + stack should be reduced before pushing a new operator. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ConstraintOperator.left_precedence"> + <summary> + The precedence value used when the operator + is about to be pushed to the stack. + </summary> + </member> + <member name="F:NUnit.Framework.Constraints.ConstraintOperator.right_precedence"> + <summary> + The precedence value used when the operator + is on the top of the stack. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ConstraintOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)"> + <summary> + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + </summary> + <param name="stack"></param> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftContext"> + <summary> + The syntax element preceding this operator + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightContext"> + <summary> + The syntax element folowing this operator + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftPrecedence"> + <summary> + The precedence value used when the operator + is about to be pushed to the stack. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightPrecedence"> + <summary> + The precedence value used when the operator + is on the top of the stack. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PrefixOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)"> + <summary> + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + </summary> + <param name="stack"></param> + </member> + <member name="M:NUnit.Framework.Constraints.PrefixOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns the constraint created by applying this + prefix to another constraint. + </summary> + <param name="constraint"></param> + <returns></returns> + </member> + <member name="M:NUnit.Framework.Constraints.CollectionOperator.#ctor"> + <summary> + Constructs a CollectionOperator + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AllOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + they all succeed. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.AndOperator"> + <summary> + Operator that requires both it's arguments to succeed + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.BinaryOperator"> + <summary> + Abstract base class for all binary operators + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.BinaryOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)"> + <summary> + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + </summary> + <param name="stack"></param> + </member> + <member name="M:NUnit.Framework.Constraints.BinaryOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + Abstract method that produces a constraint by applying + the operator to its left and right constraint arguments. + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.BinaryOperator.LeftPrecedence"> + <summary> + Gets the left precedence of the operator + </summary> + </member> + <member name="P:NUnit.Framework.Constraints.BinaryOperator.RightPrecedence"> + <summary> + Gets the right precedence of the operator + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AndOperator.#ctor"> + <summary> + Construct an AndOperator + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AndOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + Apply the operator to produce an AndConstraint + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.AttributeOperator"> + <summary> + Operator that tests for the presence of a particular attribute + on a type and optionally applies further tests to the attribute. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.SelfResolvingOperator"> + <summary> + Abstract base class for operators that are able to reduce to a + constraint whether or not another syntactic element follows. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeOperator.#ctor(System.Type)"> + <summary> + Construct an AttributeOperator for a particular Type + </summary> + <param name="type">The Type of attribute tested</param> + </member> + <member name="M:NUnit.Framework.Constraints.AttributeOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)"> + <summary> + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ExactCountOperator"> + <summary> + Represents a constraint that succeeds if the specified + count of members of a collection match a base constraint. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ExactCountOperator.#ctor(System.Int32)"> + <summary> + Construct an ExactCountOperator for a specified count + </summary> + <param name="expectedCount">The expected count</param> + </member> + <member name="M:NUnit.Framework.Constraints.ExactCountOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + none of them succeed. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.NoneOperator"> + <summary> + Represents a constraint that succeeds if none of the + members of a collection match a base constraint. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NoneOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + none of them succeed. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.NotOperator"> + <summary> + Negates the test of the constraint it wraps. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NotOperator.#ctor"> + <summary> + Constructs a new NotOperator + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.NotOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns a NotConstraint applied to its argument. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.OrOperator"> + <summary> + Operator that requires at least one of it's arguments to succeed + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.OrOperator.#ctor"> + <summary> + Construct an OrOperator + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.OrOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)"> + <summary> + Apply the operator to produce an OrConstraint + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.PropOperator"> + <summary> + Operator used to test for the presence of a named Property + on an object and optionally apply further tests to the + value of that property. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PropOperator.#ctor(System.String)"> + <summary> + Constructs a PropOperator for a particular named property + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.PropOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)"> + <summary> + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + </summary> + <param name="stack"></param> + </member> + <member name="P:NUnit.Framework.Constraints.PropOperator.Name"> + <summary> + Gets the name of the property to which the operator applies + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.SomeOperator"> + <summary> + Represents a constraint that succeeds if any of the + members of a collection match a base constraint. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.SomeOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + any of them succeed. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.ThrowsOperator"> + <summary> + Operator that tests that an exception is thrown and + optionally applies further tests to the exception. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsOperator.#ctor"> + <summary> + Construct a ThrowsOperator + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.ThrowsOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)"> + <summary> + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + </summary> + </member> + <member name="T:NUnit.Framework.Constraints.WithOperator"> + <summary> + Represents a constraint that simply wraps the + constraint provided as an argument, without any + further functionality, but which modifes the + order of evaluation because of its precedence. + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.WithOperator.#ctor"> + <summary> + Constructor for the WithOperator + </summary> + </member> + <member name="M:NUnit.Framework.Constraints.WithOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)"> + <summary> + Returns a constraint that wraps its argument + </summary> + </member> + <member name="T:NUnit.Framework.AssertionException"> + <summary> + Thrown when an assertion failed. + </summary> + </member> + <member name="M:NUnit.Framework.AssertionException.#ctor(System.String)"> + <param name="message">The error message that explains + the reason for the exception</param> + </member> + <member name="M:NUnit.Framework.AssertionException.#ctor(System.String,System.Exception)"> + <param name="message">The error message that explains + the reason for the exception</param> + <param name="inner">The exception that caused the + current exception</param> + </member> + <member name="M:NUnit.Framework.AssertionException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Serialization Constructor + </summary> + </member> + <member name="T:NUnit.Framework.IgnoreException"> + <summary> + Thrown when an assertion failed. + </summary> + </member> + <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String)"> + <param name="message"></param> + </member> + <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String,System.Exception)"> + <param name="message">The error message that explains + the reason for the exception</param> + <param name="inner">The exception that caused the + current exception</param> + </member> + <member name="M:NUnit.Framework.IgnoreException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Serialization Constructor + </summary> + </member> + <member name="T:NUnit.Framework.InconclusiveException"> + <summary> + Thrown when a test executes inconclusively. + </summary> + </member> + <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String)"> + <param name="message">The error message that explains + the reason for the exception</param> + </member> + <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String,System.Exception)"> + <param name="message">The error message that explains + the reason for the exception</param> + <param name="inner">The exception that caused the + current exception</param> + </member> + <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Serialization Constructor + </summary> + </member> + <member name="T:NUnit.Framework.SuccessException"> + <summary> + Thrown when an assertion failed. + </summary> + </member> + <member name="M:NUnit.Framework.SuccessException.#ctor(System.String)"> + <param name="message"></param> + </member> + <member name="M:NUnit.Framework.SuccessException.#ctor(System.String,System.Exception)"> + <param name="message">The error message that explains + the reason for the exception</param> + <param name="inner">The exception that caused the + current exception</param> + </member> + <member name="M:NUnit.Framework.SuccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Serialization Constructor + </summary> + </member> + <member name="T:NUnit.Framework.INUnitEqualityComparer`1"> + <summary> + + </summary> + <typeparam name="T"></typeparam> + </member> + <member name="M:NUnit.Framework.INUnitEqualityComparer`1.AreEqual(`0,`0,NUnit.Framework.Constraints.Tolerance@)"> + <summary> + Compares two objects of a given Type for equality within a tolerance + </summary> + <param name="x">The first object to compare</param> + <param name="y">The second object to compare</param> + <param name="tolerance">The tolerance to use in the comparison</param> + <returns></returns> + </member> + </members> +</doc>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/NUnit.2.6.3/license.txt Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,15 @@ +Copyright 2002-2013 Charlie Poole +Copyright 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov +Copyright 2000-2002 Philip A. Craig + +This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required. + +Portions Copyright 2002-2013 Charlie Poole or Copyright 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov or Copyright 2000-2002 Philip A. Craig + +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source distribution.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Unity.3.0.1304.1/Unity.3.0.1304.1.nuspec Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,17 @@ +<?xml version="1.0"?> +<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"> + <metadata> + <id>Unity</id> + <version>3.0.1304.1</version> + <title>Unity</title> + <authors>Microsoft</authors> + <owners>Microsoft</owners> + <licenseUrl>http://www.opensource.org/licenses/ms-pl</licenseUrl> + <projectUrl>http://msdn.microsoft.com/unity</projectUrl> + <iconUrl>http://nuget.org/Media/Default/Packages/Unity/2.0/entlib_new_icon_100x100.png</iconUrl> + <requireLicenseAcceptance>true</requireLicenseAcceptance> + <description>The Unity Application Block (Unity) is a lightweight extensible dependency injection container with support for constructor, property, and method call injection. It facilitates loosely-coupled design.</description> + <summary>The Unity Application Block (Unity) is a lightweight extensible dependency injection container with support for constructor, property, and method call injection.</summary> + <tags>Unity EntLib EntLib6 IoC DI container dependency injection inversion control LOB WinRT Win8 Windows8 NetCore WindowsStoreApps WindowsStore</tags> + </metadata> +</package> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Unity.3.0.1304.1/UnityConfiguration30.xsd Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,319 @@ +<?xml version="1.0" encoding="utf-8"?> +<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.microsoft.com/practices/2010/unity" + targetNamespace="http://schemas.microsoft.com/practices/2010/unity" + elementFormDefault="qualified" + attributeFormDefault="unqualified"> + + <!-- Core unity config --> + + <xs:element name="unity" type="UnityConfigurationSection" /> + + <xs:complexType name="UnityConfigurationSection"> + <xs:sequence> + <xs:choice minOccurs="0" maxOccurs="unbounded"> + <xs:element name="container" type="ContainerElement"/> + <xs:element name="alias" type="AliasElement" /> + <xs:element name="sectionExtension" type="SectionExtensionElement" /> + <xs:element name="namespace" type="NamedElement" /> + <xs:element name="assembly" type="NamedElement" /> + </xs:choice> + </xs:sequence> + </xs:complexType> + + <xs:complexType name="Containers"> + <xs:sequence> + <xs:element name="container" minOccurs="0" maxOccurs="unbounded" type="ContainerElement"/> + </xs:sequence> + </xs:complexType> + + <xs:complexType name="ContainerElement"> + <xs:sequence> + <xs:choice minOccurs="0" maxOccurs="unbounded"> + <xs:element name="instance" type="InstanceElement"/> + <xs:element name="register" type="RegisterElement"/> + <xs:element name="extension" type="ContainerExtensionElement"/> + <xs:element name="interception" type="InterceptionElement"/> + <xs:element name="interceptors" type="InterceptorsElement"/> + </xs:choice> + </xs:sequence> + <xs:attribute name="name" type="IdentifierName_Type"/> + </xs:complexType> + + <xs:complexType name="InstanceElement"> + <xs:attribute name="name" type="IdentifierName_Type"/> + <xs:attribute name="type" type="TypeName_Type"/> + <xs:attribute name="value" type="LiteralValue_Type"/> + <xs:attribute name="typeConverter" type="TypeName_Type"/> + </xs:complexType> + + <xs:complexType name="ContainerExtensionElement"> + <xs:attribute name="type" type="ContainerExtensionTypeName_Type" use="required"/> + </xs:complexType> + + <xs:complexType name="RegisterElement"> + <xs:group ref="InjectionGroup"/> + <xs:attribute name="type" type="TypeName_Type" use="required" /> + <xs:attribute name="name" type="IdentifierName_Type" /> + <xs:attribute name="mapTo" type="TypeName_Type"/> + </xs:complexType> + + <xs:complexType name="LifetimeElement"> + <xs:attribute name="type" type="LifetimeTypeName_Type" use="required"/> + <xs:attribute name="value" type="LiteralValue_Type"/> + <xs:attribute name="typeConverter" type="TypeName_Type"/> + </xs:complexType> + + <xs:complexType name="ConstructorElement"> + <xs:sequence minOccurs="0" maxOccurs="unbounded"> + <xs:element name="param" type="ParameterElement"/> + </xs:sequence> + </xs:complexType> + + <xs:complexType name="MethodElement"> + <xs:sequence minOccurs="0" maxOccurs="unbounded"> + <xs:element name="param" type="ParameterElement"/> + </xs:sequence> + <xs:attribute name="name" type="IdentifierName_Type" use="required"/> + </xs:complexType> + + <xs:complexType name="PropertyElement"> + <xs:group ref="ValueResolutionGroup" minOccurs="0"/> + <xs:attribute name="name" type="IdentifierName_Type" use="required"/> + <xs:attributeGroup ref="ValueOptimizationAttributes"/> + </xs:complexType> + + <xs:complexType name="ParameterElement"> + <xs:group ref="ValueResolutionGroup" minOccurs="0"/> + <xs:attribute name="name" type="IdentifierName_Type"/> + <xs:attribute name="type" type="TypeName_Type"/> + <xs:attributeGroup ref="ValueOptimizationAttributes"/> + </xs:complexType> + + <xs:complexType name="DependencyElement"> + <xs:attribute name="name" type="IdentifierName_Type"/> + <xs:attribute name="type" type="TypeName_Type"/> + </xs:complexType> + + <xs:complexType name="ValueElement"> + <xs:attribute name="value" type="LiteralValue_Type"/> + <xs:attribute name="typeConverter" type="TypeName_Type"/> + </xs:complexType> + + <xs:complexType name="ArrayElement"> + <xs:group ref="ValueResolutionGroup" minOccurs="0" maxOccurs="unbounded"/> + <xs:attribute name="type" type="TypeName_Type"/> + </xs:complexType> + + <xs:complexType name="OptionalElement"> + <xs:attribute name="name" type="IdentifierName_Type"/> + <xs:attribute name="type" type="TypeName_Type"/> + </xs:complexType> + + + <xs:complexType name="AliasElement"> + <xs:attribute name="alias" type="IdentifierName_Type" use="required"/> + <xs:attribute name="type" type="TypeName_Type" use="required"/> + </xs:complexType> + + + <xs:complexType name="SectionExtensionElement"> + <xs:attribute name="prefix" type="IdentifierName_Type"/> + <xs:attribute name="type" type="SectionExtensionTypeName_Type" use="required"/> + </xs:complexType> + + + <xs:attributeGroup name="ValueOptimizationAttributes"> + <xs:attribute name="value" type="LiteralValue_Type"/> + <xs:attribute name="dependencyName" type="IdentifierName_Type"/> + <xs:attribute name="dependencyType" type="TypeName_Type"/> + </xs:attributeGroup> + + <xs:group name="ValueResolutionGroup"> + <xs:choice> + <xs:element name="value" type="ValueElement"/> + <xs:element name="dependency" type="DependencyElement"/> + <xs:element name="array" type="ArrayElement"/> + <xs:element name="optional" type="OptionalElement"/> + </xs:choice> + </xs:group> + + <xs:group name="InjectionGroup"> + <xs:sequence> + <xs:element minOccurs="0" name="lifetime" type="LifetimeElement"/> + <xs:element minOccurs="0" name="constructor" type="ConstructorElement"/> + <xs:choice minOccurs="0" maxOccurs="unbounded"> + <xs:element name="method" type="MethodElement"/> + <xs:element name="property" type="PropertyElement"/> + <xs:element name="interceptor" type="InterceptorElement"/> + <xs:element name="interceptionBehavior" type="InterceptionBehaviorElement"/> + <xs:element name="addInterface" type="AddInterfaceElement"/> + <xs:element name="policyInjection" type="PolicyInjectionElement"/> + </xs:choice> + </xs:sequence> + </xs:group> + + <!-- Interception config --> + + <xs:complexType name="InterceptionElement"> + <xs:choice minOccurs="0" maxOccurs="unbounded"> + <xs:element name="policy" type="PolicyElement"/> + </xs:choice> + </xs:complexType> + + <xs:complexType name="PolicyElement"> + <xs:choice minOccurs="0" maxOccurs="unbounded"> + <xs:element name="callHandler" type="CallHandlerElement"/> + <xs:element name="matchingRule" type="MatchingRuleElement"/> + </xs:choice> + <xs:attribute name="name" type="IdentifierName_Type" use="required"/> + </xs:complexType> + + <xs:complexType name="CallHandlerElement"> + <xs:group ref="InjectionGroup"/> + <xs:attribute name="type" type="TypeName_Type"/> + <xs:attribute name="name" type="IdentifierName_Type" use="required"/> + </xs:complexType> + + <xs:complexType name="MatchingRuleElement"> + <xs:group ref="InjectionGroup"/> + <xs:attribute name="type" type="MatchingRuleTypeName_Type"/> + <xs:attribute name="name" type="IdentifierName_Type" use="required"/> + </xs:complexType> + + <xs:complexType name="InterceptorElement"> + <xs:attribute name="name" type="IdentifierName_Type"/> + <xs:attribute name="type" type="InterceptorTypeName_Type"/> + <xs:attribute name="isDefaultForType" type="boolean_Type2"/> + </xs:complexType> + + <xs:complexType name="InterceptionBehaviorElement"> + <xs:attribute name="name" type="IdentifierName_Type"/> + <xs:attribute name="type" type="TypeName_Type"/> + <xs:attribute name="isDefaultForType" type="boolean_Type2"/> + </xs:complexType> + + <xs:complexType name="AddInterfaceElement"> + <xs:attribute name="type" type="TypeName_Type" use="required"/> + </xs:complexType> + + <xs:complexType name="PolicyInjectionElement"/> + + <xs:complexType name="InterceptorsElement"> + <xs:sequence minOccurs="0" maxOccurs="unbounded"> + <xs:element name="interceptor" type="InterceptorsInterceptorElement"/> + </xs:sequence> + </xs:complexType> + + <xs:complexType name="InterceptorsInterceptorElement"> + <xs:choice minOccurs="0" maxOccurs="unbounded"> + <xs:element name="key" type="KeyElement"/> + <xs:element name="default" type="DefaultElement"/> + </xs:choice> + <xs:attribute name="type" type="InterceptorTypeName_Type"/> + <xs:attribute name="value" type="LiteralValue_Type"/> + <xs:attribute name="typeConverter" type="TypeName_Type"/> + </xs:complexType> + + <xs:complexType name="KeyElement"> + <xs:attribute name="type" type="TypeName_Type" use="required"/> + <xs:attribute name="name" type="IdentifierName_Type"/> + </xs:complexType> + + <xs:complexType name="DefaultElement"> + <xs:attribute name="type" type="TypeName_Type" use="required"/> + </xs:complexType> + + <!-- common types --> + + <xs:simpleType name="LiteralValue_Type"> + <xs:restriction base="xs:string"/> + </xs:simpleType> + + <xs:simpleType name="TypeName_Type"> + <xs:restriction base="xs:string"/> + </xs:simpleType> + + <xs:simpleType name="LifetimeTypeName_Type"> + <xs:union memberTypes="TypeName_Type"> + <xs:simpleType> + <xs:restriction base="xs:NMTOKEN"> + <xs:enumeration value="singleton"/> + <xs:enumeration value="transient"/> + <xs:enumeration value="perthread"/> + <xs:enumeration value="external"/> + <xs:enumeration value="hierarchical"/> + <xs:enumeration value="resolve"/> + <xs:enumeration value="perresolve"/> + </xs:restriction> + </xs:simpleType> + </xs:union> + </xs:simpleType> + + <xs:simpleType name="ContainerExtensionTypeName_Type"> + <xs:union memberTypes="TypeName_Type"> + <xs:simpleType> + <xs:restriction base="xs:NMTOKEN"> + <xs:enumeration value="Interception"/> + </xs:restriction> + </xs:simpleType> + </xs:union> + </xs:simpleType> + + <xs:simpleType name="SectionExtensionTypeName_Type"> + <xs:union memberTypes="TypeName_Type"> + <xs:simpleType> + <xs:restriction base="xs:string"> + <xs:enumeration value="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration"/> + </xs:restriction> + </xs:simpleType> + </xs:union> + </xs:simpleType> + + <xs:simpleType name="InterceptorTypeName_Type"> + <xs:union memberTypes="TypeName_Type"> + <xs:simpleType> + <xs:restriction base="xs:NMTOKEN"> + <xs:enumeration value="VirtualMethodInterceptor"/> + <xs:enumeration value="InterfaceInterceptor"/> + <xs:enumeration value="TransparentProxyInterceptor"/> + </xs:restriction> + </xs:simpleType> + </xs:union> + </xs:simpleType> + + <xs:simpleType name="MatchingRuleTypeName_Type"> + <xs:union memberTypes="TypeName_Type"> + <xs:simpleType> + <xs:restriction base="xs:NMTOKEN"> + <xs:enumeration value="AssemblyMatchingRule"/> + <xs:enumeration value="CustomAttributeMatchingRule"/> + <xs:enumeration value="MemberNameMatchingRule"/> + <xs:enumeration value="NamespaceMatchingRule"/> + <xs:enumeration value="ParameterTypeMatchingRule"/> + <xs:enumeration value="PropertyMatchingRule"/> + <xs:enumeration value="TagAttributeMatchingRule"/> + <xs:enumeration value="TypeMatchingRule"/> + </xs:restriction> + </xs:simpleType> + </xs:union> + </xs:simpleType> + + <xs:simpleType name="IdentifierName_Type"> + <xs:restriction base="xs:string"/> + </xs:simpleType> + + <xs:simpleType name="boolean_Type2"> + <xs:restriction base="xs:boolean"> + <xs:pattern value="true" /> + <xs:pattern value="false" /> + </xs:restriction> + </xs:simpleType> + + <xs:complexType name="Empty"/> + + <xs:complexType name="NamedElement"> + <xs:attribute name="name" type="IdentifierName_Type" use="required"/> + </xs:complexType> + +</xs:schema>
Binary file src/packages/Unity.3.0.1304.1/lib/Net45/Microsoft.Practices.Unity.Configuration.dll has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Unity.3.0.1304.1/lib/Net45/Microsoft.Practices.Unity.Configuration.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,2451 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>Microsoft.Practices.Unity.Configuration</name> + </assembly> + <members> + <member name="T:Microsoft.Practices.Unity.Configuration.AliasElement"> + <summary> + A configuration element storing information about a single type alias. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElement"> + <summary> + Base class for configuration elements with a default implementation of + public deserialization. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElement.Deserialize(System.Xml.XmlReader)"> + <summary> + Load this element from the given <see cref="T:System.Xml.XmlReader"/>. + </summary> + <param name="reader">Contains the XML to initialize from.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.AliasElement.#ctor"> + <summary> + Construct a new, uninitialized <see cref="T:Microsoft.Practices.Unity.Configuration.AliasElement"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.AliasElement.#ctor(System.String,System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.Configuration.AliasElement"/> that is initialized + to alias <paramref name="alias"/> to the target <paramref name="targetType"/>. + </summary> + <param name="alias">Alias to use.</param> + <param name="targetType">Type that is aliased.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.AliasElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.AliasElement.Alias"> + <summary> + The alias used for this type. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.AliasElement.TypeName"> + <summary> + The fully qualified name this alias refers to. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.AliasElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.AliasElement"/>s. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollection`1"> + <summary> + Specialization of <see cref="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1"/> + that provides a canned implmentation of <see cref="M:System.Configuration.ConfigurationElementCollection.CreateNewElement"/>. + </summary> + <typeparam name="TElement">Type of configuration element in the collection.</typeparam> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1"> + <summary> + A base helper class for implementing configuration collections. + </summary> + <typeparam name="TElement">Type of configuration element contained in + the collection.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.GetElement(System.Int32)"> + <summary> + Plug point to get objects out of the collection. + </summary> + <param name="index">Index in the collection to retrieve the item from.</param> + <returns>Item at that index or null if not present.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.GetElement(System.Object)"> + <summary> + Plug point to get objects out of the collection. + </summary> + <param name="key">Key to look up the object by.</param> + <returns>Item with that key or null if not present.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.Deserialize(System.Xml.XmlReader)"> + <summary> + Load this element from the given <see cref="T:System.Xml.XmlReader"/>. + </summary> + <param name="reader">Contains the XML to initialize from.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.Add(`0)"> + <summary> + Add a new element to the collection. + </summary> + <param name="element">Element to add.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.RemoveAt(System.Int32)"> + <summary> + Remove an element from the collection at the given index. + </summary> + <param name="index">The index of the item to remove.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.Clear"> + <summary> + Remove all the items in the collection. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.SerializeElementContents(System.Xml.XmlWriter,System.String)"> + <summary> + Write out the contents of this collection to the given + <paramref name="writer"/> without a containing element + corresponding directly to this container element. Each + child element will have a tag name given by + <paramref name="elementName"/>. + </summary> + <param name="writer"><see cref="T:System.Xml.XmlWriter"/> to output XML to.</param> + <param name="elementName">Name of tag to generate.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase`1.Item(System.Int32)"> + <summary> + Indexer to retrieve items in the collection by index. + </summary> + <param name="index">Index of the item to get or set.</param> + <returns>The item at the given index.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollection`1.CreateNewElement"> + <summary> + When overridden in a derived class, creates a new <see cref="T:System.Configuration.ConfigurationElement"/>. + </summary> + <returns> + A new <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.AliasElementCollection.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Causes the configuration system to throw an exception. + </summary> + <returns> + true if the unrecognized element was deserialized successfully; otherwise, false. The default is false. + </returns> + <param name="elementName">The name of the unrecognized element. + </param><param name="reader">An input stream that reads XML from the configuration file. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element specified in <paramref name="elementName"/> is the <clear> element. + </exception><exception cref="T:System.ArgumentException"><paramref name="elementName"/> starts with the reserved prefix "config" or "lock". + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.AliasElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.AliasElementCollection.Item(System.String)"> + <summary> + Indexer that allows you to get or set an alias by the alias name. + </summary> + <param name="alias">Alias of element to get or set.</param> + <returns>The type name at that alias.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ArrayElement"> + <summary> + A configuration element used to configure injection of + a specific set of values into an array. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"> + <summary> + Base class for configuration elements that describe a value that will + be injected. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterValueElement.#ctor"> + <summary> + Initialize a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterValueElement.GetInjectionParameterValue(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Generate an <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object + that will be used to configure the container for a type registration. + </summary> + <param name="container">Container that is being configured. Supplied in order + to let custom implementations retrieve services; do not configure the container + directly in this method.</param> + <param name="parameterType">Type of the </param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterValueElement.GuardPropertyValueIsPresent(System.Collections.Generic.IDictionary{System.String,System.String},System.String)"> + <summary> + Validate that an expected attribute is present in the given + dictionary and that it has a non-empty value. + </summary> + <param name="propertyValues">Dictionary of name/value pairs to check.</param> + <param name="requiredProperty">attribute name to check.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ParameterValueElement.Key"> + <summary> + Return a unique string that can be used to identify this object. Used + by the configuration collection support. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ArrayElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ArrayElement.GetInjectionParameterValue(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Generate an <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object + that will be used to configure the container for a type registration. + </summary> + <param name="container">Container that is being configured. Supplied in order + to let custom implementations retrieve services; do not configure the container + directly in this method.</param> + <param name="parameterType">Type of the </param> + <returns></returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ArrayElement.TypeName"> + <summary> + Type of array to inject. This is actually the type of the array elements, + not the array type. Optional, if not specified we take the type from + our containing element. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ArrayElement.Values"> + <summary> + Values used to calculate the contents of the array. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.AssemblyElement"> + <summary> + A configuration element representing the namespace + tags in the config file. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.NamedElement"> + <summary> + An element with a single "name" property, used for + the namespaces and assemblies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.NamedElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.NamedElement.Name"> + <summary> + Name attribute for this element. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.AssemblyElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.AssemblyElement"/>s in configuration. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.AssemblyElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ConfigurationElementExtensions"> + <summary> + Helpful extension methods when implementing configuration sections + that deserialize "unwrapped" elements - elements that should be + deserialized into a container but can be present outside + that container in the actual config file. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ConfigurationElementExtensions.ReadUnwrappedElement``1(System.Configuration.ConfigurationElement,System.Xml.XmlReader,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase{``0})"> + <summary> + Deserialize an element of the given type, store it in + the collection object, and + </summary> + <typeparam name="TElementType">Type of element to create and deserialize.</typeparam> + <param name="baseElement">Parent element containing element to deserialize.</param> + <param name="reader">Xml reader containing state to deserialize from.</param> + <param name="elementCollection">Collection to store the created element into.</param> + <returns>The created element.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ConfigurationElementExtensions.ReadElementByType``1(System.Configuration.ConfigurationElement,System.Xml.XmlReader,System.Type,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DeserializableConfigurationElementCollectionBase{``0})"> + <summary> + Deserialize an element, basing the element type on the one + supplied at runtime, and then store the element into the + given <paramref name="elementCollection"/>. + </summary> + <remarks>This method is useful when reading elements into a polymorphic collection.</remarks> + <typeparam name="TElementType">Base type of element to store.</typeparam> + <param name="baseElement">Element that contains the collection being stored into.</param> + <param name="reader">Xml Reader containing state to deserialize from.</param> + <param name="elementType">Runtime type of element to create.</param> + <param name="elementCollection">Collection to store the created element into.</param> + <returns>The created element.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream"> + <summary> + Class that tracks the current input state of the parser. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder"> + <summary> + A simple implementing of the rules for a Parsing Expression Grammar + parsing algorithm. This supplies basic methods to do the primitives + of the PEG, and combinators to create larger rules. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.Any(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream)"> + <summary> + The PEG "dot" operator that matches and consumes one character. + </summary> + <param name="input">Input to the parser.</param> + <returns>The parse result.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.Match(System.Char)"> + <summary> + Parse function generator that returns a method to match a single, + specific character. + </summary> + <param name="charToMatch">Character to match.</param> + <returns>The generated parsing function.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.Match(System.Func{System.Char,System.Boolean})"> + <summary> + Parse function generator that checks if the current character matches + the predicate supplied. + </summary> + <param name="predicate">Predicate used to determine if the character is in + the given range.</param> + <returns>The generated parsing function.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.ZeroOrMore(System.Func{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult})"> + <summary> + The "*" operator - match zero or more of the inner parse expressions. + </summary> + <param name="inner">Parse method to repeat matching.</param> + <returns>The generated parsing function.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.Sequence(System.Func{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult}[])"> + <summary> + Parsing combinator that matches all of the given expressions in + order, or matches none of them. + </summary> + <param name="expressions">Expressions that form the sequence to match.</param> + <returns>The combined sequence.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.FirstOf(System.Func{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult}[])"> + <summary> + Parsing combinator that implements the PEG prioritized choice operator. Basically, + try each of the expressions in order, and match if any of them match, stopping on the + first match. + </summary> + <param name="expressions">Expressions that form the set of alternatives.</param> + <returns>The combined parsing method.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.Not(System.Func{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult})"> + <summary> + Parsing combinator implementing the "not" predicate. This wraps + the given <paramref name="expression"/> parsing method with a check + to see if it matched. If it matched, then the Not fails, and vice + versa. The result consumes no input. + </summary> + <param name="expression">The parse method to wrap.</param> + <returns>The generated parsing function.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.EOF(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream)"> + <summary> + Parsing expression that matches End of input. + </summary> + <param name="input">Parser input.</param> + <returns>Parse result</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.WithAction(System.Func{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult},System.Action{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult})"> + <summary> + Combinator that executes an action if the given expression matched. + </summary> + <param name="expression">Parsing expression to match.</param> + <param name="onMatched">Action to execute if <paramref name="expression"/> + matched. Input is the matched text from <paramref name="expression"/>.</param> + <returns>The result of <paramref name="expression"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseBuilder.WithAction(System.Func{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.InputStream,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult},System.Func{Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult})"> + <summary> + Combinator that executes an action if the given expression matched. + </summary> + <param name="expression">parsing expression to match.</param> + <param name="onMatched">Method to execute if a match happens. This method returns + the <see cref="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult"/> that will be returned from the combined expression.</param> + <returns>The result of <paramref name="onMatched"/> if expression matched, else + whatever <paramref name="expression"/> returned.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult"> + <summary> + Object containing the result of attempting to match a PEG rule. + This object is the return type for all parsing methods. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult.Matched"> + <summary> + Did the rule match? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult.MatchedString"> + <summary> + The characters that were matched (if any) + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult.ResultData"> + <summary> + Any extra information provided by the parsing expression + (only set if the parse matched). The nature + of the data varies depending on the parsing expression. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult"> + <summary> + Helper methods to make it easier to pull the data + out of the result of a sequence expression. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.Add(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult)"> + <summary> + Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </summary> + <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </param><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.Clear"> + <summary> + Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </summary> + <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.Contains(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult)"> + <summary> + Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"/> contains a specific value. + </summary> + <returns> + true if <paramref name="item"/> is found in the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. + </returns> + <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.CopyTo(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult[],System.Int32)"> + <summary> + Copies the elements of the sequence to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index. + </summary> + <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from this sequence. The <see cref="T:System.Array"/> must have zero-based indexing. + </param><param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins. + </param><exception cref="T:System.ArgumentNullException"><paramref name="array"/> is null. + </exception><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="arrayIndex"/> is less than 0. + </exception><exception cref="T:System.ArgumentException"><paramref name="array"/> is multidimensional. + -or- + <paramref name="arrayIndex"/> is equal to or greater than the length of <paramref name="array"/>. + -or- + The number of elements in the source is greater than the available space from <paramref name="arrayIndex"/> to the end of the destination <paramref name="array"/>. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.Remove(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult)"> + <summary> + Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </summary> + <returns> + true if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>. + </returns> + <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </param><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.IndexOf(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult)"> + <summary> + Determines the index of a specific item in the <see cref="T:System.Collections.Generic.IList`1"/>. + </summary> + <returns> + The index of <paramref name="item"/> if found in the list; otherwise, -1. + </returns> + <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.IList`1"/>. + </param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.Insert(System.Int32,Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ParseResult)"> + <summary> + Inserts an item to the <see cref="T:System.Collections.Generic.IList`1"/> at the specified index. + </summary> + <param name="index">The zero-based index at which <paramref name="item"/> should be inserted. + </param><param name="item">The object to insert into the <see cref="T:System.Collections.Generic.IList`1"/>. + </param><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is not a valid index in the <see cref="T:System.Collections.Generic.IList`1"/>. + </exception><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.IList`1"/> is read-only. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.RemoveAt(System.Int32)"> + <summary> + Removes the <see cref="T:System.Collections.Generic.IList`1"/> item at the specified index. + </summary> + <param name="index">The zero-based index of the item to remove. + </param><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is not a valid index in the <see cref="T:System.Collections.Generic.IList`1"/>. + </exception><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.IList`1"/> is read-only. + </exception> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.Count"> + <summary> + Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </summary> + <returns> + The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. + </returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.IsReadOnly"> + <summary> + Gets a value indicating whether the <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only. + </summary> + <returns> + true if the <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only; otherwise, false. + </returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.SequenceResult.Item(System.Int32)"> + <summary> + Gets or sets the element at the specified index. + </summary> + <returns> + The element at the specified index. + </returns> + <param name="index">The zero-based index of the element to get or set. + </param><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is not a valid index in the <see cref="T:System.Collections.Generic.IList`1"/>. + </exception><exception cref="T:System.NotSupportedException">The property is set and the <see cref="T:System.Collections.Generic.IList`1"/> is read-only. + </exception> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeNameInfo"> + <summary> + Class containing information about a type name. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeNameInfo.Name"> + <summary> + The base name of the class + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeNameInfo.Namespace"> + <summary> + Namespace if any + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeNameInfo.AssemblyName"> + <summary> + Assembly name, if any + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.XmlWriterExtensions"> + <summary> + Helper methods on <see cref="T:System.Xml.XmlWriter"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.XmlWriterExtensions.WriteElement(System.Xml.XmlWriter,System.String,System.Action{System.Xml.XmlWriter})"> + <summary> + A helper method to make it more foolproof to write elements. This takes care of writing the + start and end elment tags, and takes a nested closure with the code to write the content of + the tag. That way the caller doesn't need to worry about the details of getting the start + and end tags correct. + </summary> + <remarks> + We don't support XML Namespaces here because .NET configuration doesn't use them so + we don't need it for this current implementation. + </remarks> + <param name="writer">XmlWriter to write to.</param> + <param name="elementName">Name of element.</param> + <param name="writeContent">Nested lambda which, when executed, will create the content for the + element.</param> + <returns><paramref name="writer"/> (for method chaining if desired).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.XmlWriterExtensions.WriteAttributeIfNotEmpty(System.Xml.XmlWriter,System.String,System.String)"> + <summary> + A helper method to make it easier to output attributes. If the <paramref name="attributeValue"/> is + null or an empty string, output nothing, else output the given XML attribute. + </summary> + <param name="writer">Writer to output to.</param> + <param name="attributeName">Attribute name to write.</param> + <param name="attributeValue">Value for the attribute.</param> + <returns><paramref name="writer"/> (for method chaining if desired).</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElement"> + <summary> + A base class for those elements that can be used + to configure a unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElement.#ctor"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElement"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElement.ConfigureContainer(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Apply this element's configuration to the given <paramref name="container"/>. + </summary> + <param name="container">Container to configure.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElement.Key"> + <summary> + Return a unique key that can be used to manage this element in a collection. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DictionaryExtensions"> + <summary> + A couple of useful extension methods on IDictionary + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.DictionaryExtensions.GetOrNull``2(System.Collections.Generic.IDictionary{``0,``1},``0)"> + <summary> + Get the value from a dictionary, or null if there is no value. + </summary> + <typeparam name="TKey">Key type of dictionary.</typeparam> + <typeparam name="TValue">Value type of dictionary.</typeparam> + <param name="dictionary">Dictionary to search.</param> + <param name="key">Key to look up.</param> + <returns>The value at the key or null if not in the dictionary.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap`1"> + <summary> + A helper class used to map element tag names to a handler method + used to interpret that element. + </summary> + <typeparam name="TContainingElement"></typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap`1.Add(System.String,System.Action{`0,System.Xml.XmlReader})"> + <summary> + Add method to enable dictionary initializer syntax + </summary> + <param name="elementName"></param> + <param name="processingAction"></param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap`1.ProcessElement(`0,System.String,System.Xml.XmlReader)"> + <summary> + Process an unknown element according to the map entries. + </summary> + <param name="parentElement">Parent element that hit this unknown element.</param> + <param name="elementName">Name of the unknown element.</param> + <param name="reader">XmlReader positioned at start of element.</param> + <returns>true if processed, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap`1.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap`1.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap"> + <summary> + A helper class used to map element tag names to a handler method + used to interpret that element. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.UnknownElementHandlerMap.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper"> + <summary> + A helper class that assists in deserializing parameter and property + elements. These elements both have a single "value" child element that + specify the value to inject for the property or parameter. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper.#ctor(Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.IValueProvidingElement)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper"/> that wraps reading + values and storing them in the given <paramref name="parentElement"/>. + </summary> + <param name="parentElement">Element that contains the value elements.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper.GetValue(Microsoft.Practices.Unity.Configuration.ParameterValueElement)"> + <summary> + Gets a <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/>, or if none is present, + returns a default <see cref="T:Microsoft.Practices.Unity.Configuration.DependencyElement"/>. + </summary> + <param name="currentValue">The <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/>.</param> + <returns>The given <paramref name="currentValue"/>, unless + <paramref name="currentValue"/> is null, in which case returns + a <see cref="T:Microsoft.Practices.Unity.Configuration.DependencyElement"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper.DeserializeUnrecognizedAttribute(System.String,System.String)"> + <summary> + Helper method used during deserialization to handle + attributes for the dependency and value tags. + </summary> + <param name="name">attribute name.</param> + <param name="value">attribute value.</param> + <returns>true</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper.DeserializeUnknownElement(System.String,System.Xml.XmlReader)"> + <summary> + Helper method used during deserialization to handle the default + value element tags. + </summary> + <param name="elementName">The element name.</param> + <param name="reader">XML data to read.</param> + <returns>True if deserialization succeeded, false if it failed.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper.CompleteValueElement(System.Xml.XmlReader)"> + <summary> + Call this method at the end of deserialization of your element to + set your value element. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.ValueElementHelper.SerializeParameterValueElement(System.Xml.XmlWriter,Microsoft.Practices.Unity.Configuration.ParameterValueElement,System.Boolean)"> + <summary> + Serialize a <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/> object out to XML. + This method is aware of and implements the shorthand attributes + for dependency and value elements. + </summary> + <param name="writer">Writer to output XML to.</param> + <param name="element">The <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/> to serialize.</param> + <param name="elementsOnly">If true, always output an element. If false, then + dependency and value elements will be serialized as attributes in the parent tag.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConstructorElement"> + <summary> + Configuration element representing a constructor configuration. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.InjectionMemberElement"> + <summary> + Base class for configuration elements that generate <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> + object to configure a container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InjectionMemberElement.GetInjectionMembers(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,System.String)"> + <summary> + Return the set of <see cref="T:Microsoft.Practices.Unity.InjectionMember"/>s that are needed + to configure the container according to this configuration element. + </summary> + <param name="container">Container that is being configured.</param> + <param name="fromType">Type that is being registered.</param> + <param name="toType">Type that <paramref name="fromType"/> is being mapped to.</param> + <param name="name">Name this registration is under.</param> + <returns>One or more <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects that should be + applied to the container registration.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InjectionMemberElement.GetMemberElementName(Microsoft.Practices.Unity.Configuration.InjectionMemberElement)"> + <summary> + Get the standard tag name for an <see cref="T:Microsoft.Practices.Unity.Configuration.InjectionMemberElement"/> + taking into account currently loaded section extensions. + </summary> + <param name="memberElement">Element to get the name for.</param> + <returns>The element name.</returns> + <exception cref="T:System.ArgumentException">If the member element is not currently registered + with the section.</exception> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InjectionMemberElement.Key"> + <summary> + Each element must have a unique key, which is generated by the subclasses. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InjectionMemberElement.ElementName"> + <summary> + Element name to use to serialize this into XML. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConstructorElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConstructorElement.GetInjectionMembers(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,System.String)"> + <summary> + Return the set of <see cref="T:Microsoft.Practices.Unity.InjectionMember"/>s that are needed + to configure the container according to this configuration element. + </summary> + <param name="container">Container that is being configured.</param> + <param name="fromType">Type that is being registered.</param> + <param name="toType">Type that <paramref name="fromType"/> is being mapped to.</param> + <param name="name">Name this registration is under.</param> + <returns>One or more <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects that should be + applied to the container registration.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConstructorElement.Parameters"> + <summary> + The parameters of the constructor to call. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConstructorElement.Key"> + <summary> + Each element must have a unique key, which is generated by the subclasses. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConstructorElement.ElementName"> + <summary> + Element name to use to serialize this into XML. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElement"/>s as + loaded from configuration. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElementCollection.CreateNewElement"> + <summary> + When overridden in a derived class, creates a new <see cref="T:System.Configuration.ConfigurationElement"/>. + </summary> + <returns> + A new <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ContainerElement"> + <summary> + A configuration element class defining the set of registrations to be + put into a container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerElement.Configure(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Original configuration API kept for backwards compatibility. + </summary> + <param name="container">Container to configure</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerElement.ConfigureContainer(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Apply the configuration information in this element to the + given <paramref name="container"/>. + </summary> + <param name="container">Container to configure.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerElement.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Gets a value indicating whether an unknown element is encountered during deserialization. + </summary> + <returns> + true when an unknown element is encountered while deserializing; otherwise, false. + </returns> + <param name="elementName">The name of the unknown subelement. + </param><param name="reader">The <see cref="T:System.Xml.XmlReader"/> being used for deserialization. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element identified by <paramref name="elementName"/> is locked. + - or - + One or more of the element's attributes is locked. + - or - + <paramref name="elementName"/> is unrecognized, or the element has an unrecognized attribute. + - or - + The element has a Boolean attribute with an invalid value. + - or - + An attempt was made to deserialize a property more than once. + - or - + An attempt was made to deserialize a property that is not a valid member of the element. + - or - + The element cannot contain a CDATA or text element. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerElement.Name"> + <summary> + Name for this container configuration as given in the config file. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerElement.Registrations"> + <summary> + The type registrations in this container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerElement.Instances"> + <summary> + Any instances to register in the container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerElement.Extensions"> + <summary> + Any extensions to add to the container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerElement.ConfiguringElements"> + <summary> + Set of any extra configuration elements that were added by a + section extension. + </summary> + <remarks> + This is not marked as a configuration property because we don't want + the actual property to show up as a nested element in the configuration.</remarks> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ContainerExtensionElement"> + <summary> + Configuration element representing an extension to add to a container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerExtensionElement.ConfigureContainer(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Add the extension specified in this element to the container. + </summary> + <param name="container">Container to configure.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerExtensionElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerExtensionElement.TypeName"> + <summary> + Type of the extension to add. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ContainerExtensionElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.ContainerExtensionElement"/>s. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerExtensionElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.DependencyElement"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/> derived class that describes + a parameter that should be resolved through the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.DependencyElement.#ctor"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.DependencyElement"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.DependencyElement.#ctor(System.Collections.Generic.IDictionary{System.String,System.String})"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.DependencyElement"/> with + properties initialized from the contents of + <paramref name="attributeValues"/>. + </summary> + <param name="attributeValues">Dictionary of name/value pairs to + initialize this object with.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.DependencyElement.Microsoft#Practices#Unity#Configuration#IAttributeOnlyElement#SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.DependencyElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. This + method always outputs an explicit <dependency> tag, instead of providing + attributes to the parent method. + </summary> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.DependencyElement.GetInjectionParameterValue(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Generate an <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object + that will be used to configure the container for a type registration. + </summary> + <param name="container">Container that is being configured. Supplied in order + to let custom implementations retrieve services; do not configure the container + directly in this method.</param> + <param name="parameterType">Type of the </param> + <returns></returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.DependencyElement.Name"> + <summary> + Name to use to when resolving. If empty, resolves the default. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.DependencyElement.TypeName"> + <summary> + Name of type this dependency should resolve to. This is optional; + without it the container will resolve the type of whatever + property or parameter this element is contained in. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElement"> + <summary> + Base class used to derive new elements that can occur + directly within a container element. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElement.#ctor"> + <summary> + Initialize a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElement"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElement.ConfigureContainer(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + When overridden in a derived class, this method will make configuration + calls into the given <paramref name="container"/> according to its contents. + </summary> + <param name="container">The container to configure.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElement.Key"> + <summary> + Unique key generated for use in the collection class. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElement"/>s. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElementCollection.CreateNewElement"> + <summary> + When overridden in a derived class, creates a new <see cref="T:System.Configuration.ConfigurationElement"/>. + </summary> + <returns> + A new <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionConfigurationElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ExtensionElementMap"> + <summary> + This class manages the set of extension elements + added by section elements. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.Clear"> + <summary> + Clear the current set of extension elements. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.AddContainerConfiguringElement(System.String,System.String,System.Type)"> + <summary> + Register a new ContainerExtensionConfigurationElement with he section so it + can be read. + </summary> + <param name="prefix">prefix if any.</param> + <param name="tag">tag name.</param> + <param name="elementType">Type of element to register.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.AddInjectionMemberElement(System.String,System.String,System.Type)"> + <summary> + Register a new <see cref="T:Microsoft.Practices.Unity.Configuration.InjectionMemberElement"/> with the section + so it can be read. + </summary> + <param name="prefix">prefix if any.</param> + <param name="tag">Tag name.</param> + <param name="elementType">Type of element to register.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.AddParameterValueElement(System.String,System.String,System.Type)"> + <summary> + Register a new <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/> with the section + so it can be read. + </summary> + <param name="prefix">prefix if any.</param> + <param name="tag">Tag name.</param> + <param name="elementType">Type of element to register.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.GetContainerConfiguringElementType(System.String)"> + <summary> + Retrieve the <see cref="T:Microsoft.Practices.Unity.Configuration.ContainerConfiguringElement"/> registered for the given + tag. + </summary> + <param name="tag">Tag to look up.</param> + <returns>Type of element, or null if not registered.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.GetInjectionMemberElementType(System.String)"> + <summary> + Retrieve the ContainerExtensionConfigurationElement registered for the given + tag. + </summary> + <param name="tag">Tag to look up.</param> + <returns>Type of element, or null if not registered.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.GetParameterValueElementType(System.String)"> + <summary> + Retrieve the ContainerExtensionConfigurationElement registered for the given + tag. + </summary> + <param name="tag">Tag to look up.</param> + <returns>Type of element, or null if not registered.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ExtensionElementMap.GetTagForExtensionElement(System.Configuration.ConfigurationElement)"> + <summary> + Retrieve the correct tag to use when serializing the given + <paramref name="element"/> to XML. + </summary> + <param name="element">Element to be serialized.</param> + <returns>The tag for that element type.</returns> + <exception cref="T:System.ArgumentException"> if the element is of a type that + is not registered with the section already.</exception> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.InjectionMemberElementCollection"> + <summary> + A polymorphic collection of <see cref="T:Microsoft.Practices.Unity.Configuration.InjectionMemberElement"/>s. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InjectionMemberElementCollection.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Causes the configuration system to throw an exception. + </summary> + <returns> + true if the unrecognized element was deserialized successfully; otherwise, false. The default is false. + </returns> + <param name="elementName">The name of the unrecognized element. + </param><param name="reader">An input stream that reads XML from the configuration file. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element specified in <paramref name="elementName"/> is the <clear> element. + </exception><exception cref="T:System.ArgumentException"><paramref name="elementName"/> starts with the reserved prefix "config" or "lock". + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InjectionMemberElementCollection.CreateNewElement"> + <summary> + When overridden in a derived class, creates a new <see cref="T:System.Configuration.ConfigurationElement"/>. + </summary> + <returns> + A new <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InjectionMemberElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InjectionMemberElementCollection.Item(System.String)"> + <summary> + Indexer that lets you access elements by their key. + </summary> + <param name="key">Key to retrieve element with.</param> + <returns>The element.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.InstanceElement"> + <summary> + A configuration element that describes an instance to add to the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InstanceElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InstanceElement.ConfigureContainer(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Add the instance defined by this element to the given container. + </summary> + <param name="container">Container to configure.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InstanceElement.Name"> + <summary> + Name to register instance under + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InstanceElement.Value"> + <summary> + Value for this instance + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InstanceElement.TypeName"> + <summary> + Type of the instance. If not given, defaults to string + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InstanceElement.TypeConverterTypeName"> + <summary> + Type name for the type converter to use to create the instance. If not + given, defaults to the default type converter for this instance type. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.InstanceElement.Key"> + <summary> + Key used to keep these instances unique in the config collection. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.InstanceElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.InstanceElement"/>s. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.InstanceElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.IValueProvidingElement"> + <summary> + An element that has a child Value property. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.IValueProvidingElement.Value"> + <summary> + String that will be deserialized to provide the value. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.IValueProvidingElement.DestinationName"> + <summary> + A string describing where the value this element contains + is being used. For example, if setting a property Prop1, + this should return "property Prop1" (in english). + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.LifetimeElement"> + <summary> + A configuration element that represents lifetime managers. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.LifetimeElement.CreateLifetimeManager"> + <summary> + Create the <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> described by + this element. + </summary> + <returns>A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> instance.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.LifetimeElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.LifetimeElement.TypeName"> + <summary> + Type of the lifetime manager. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.LifetimeElement.Value"> + <summary> + Extra initialization information used by the type converter for this lifetime manager. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.LifetimeElement.TypeConverterTypeName"> + <summary> + Type of <see cref="T:System.ComponentModel.TypeConverter"/> to use to create the + lifetime manager. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.MethodElement"> + <summary> + A configuration element representing a method to call. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.MethodElement.#ctor"> + <summary> + Construct a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.MethodElement"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.MethodElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.MethodElement.GetInjectionMembers(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,System.String)"> + <summary> + Return the set of <see cref="T:Microsoft.Practices.Unity.InjectionMember"/>s that are needed + to configure the container according to this configuration element. + </summary> + <param name="container">Container that is being configured.</param> + <param name="fromType">Type that is being registered.</param> + <param name="toType">Type that <paramref name="fromType"/> is being mapped to.</param> + <param name="name">Name this registration is under.</param> + <returns>One or more <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects that should be + applied to the container registration.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.MethodElement.Name"> + <summary> + Name of the method to call. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.MethodElement.Parameters"> + <summary> + Parameters to the method call. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.MethodElement.Key"> + <summary> + Each element must have a unique key, which is generated by the subclasses. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.MethodElement.ElementName"> + <summary> + Element name to use to serialize this into XML. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.NamespaceElement"> + <summary> + A configuration element representing the namespace + tags in the config file. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.NamespaceElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.NamespaceElement"/>s in configuration. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.NamespaceElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.OptionalElement"> + <summary> + A configuration element that specifies that a value + is optional. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.OptionalElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.OptionalElement.GetInjectionParameterValue(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Generate an <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object + that will be used to configure the container for a type registration. + </summary> + <param name="container">Container that is being configured. Supplied in order + to let custom implementations retrieve services; do not configure the container + directly in this method.</param> + <param name="parameterType">Type of the </param> + <returns></returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.OptionalElement.Name"> + <summary> + Name used to resolve the dependency, leave out or blank to resolve default. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.OptionalElement.TypeName"> + <summary> + Type of dependency to resolve. If left out, resolved the type of + the containing parameter or property. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ParameterElement"> + <summary> + Configuration element representing a parameter passed to a constructor + or a method. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElement.#ctor"> + <summary> + Construct a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterElement"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElement.GetParameterValue(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Returns the required <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> needed + to configure the container so that the correct value is injected. + </summary> + <param name="container">Container being configured.</param> + <param name="parameterType">Type of the parameter.</param> + <returns>The value to use to configure the container.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElement.Matches(System.Reflection.ParameterInfo)"> + <summary> + Does the information in this <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterElement"/> match + up with the given <paramref name="parameterInfo"/>? + </summary> + <param name="parameterInfo">Information about the parameter.</param> + <returns>True if this is a match, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElement.DeserializeElement(System.Xml.XmlReader,System.Boolean)"> + <summary> + Reads XML from the configuration file. + </summary> + <param name="reader">The <see cref="T:System.Xml.XmlReader"/> that reads from the configuration file. + </param><param name="serializeCollectionKey">true to serialize only the collection key properties; otherwise, false. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element to read is locked. + - or - + An attribute of the current node is not recognized. + - or - + The lock status of the current node cannot be determined. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElement.OnDeserializeUnrecognizedAttribute(System.String,System.String)"> + <summary> + Gets a value indicating whether an unknown attribute is encountered during deserialization. + </summary> + <returns> + true when an unknown attribute is encountered while deserializing; otherwise, false. + </returns> + <param name="name">The name of the unrecognized attribute. + </param><param name="value">The value of the unrecognized attribute. + </param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElement.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Gets a value indicating whether an unknown element is encountered during deserialization. + </summary> + <returns> + true when an unknown element is encountered while deserializing; otherwise, false. + </returns> + <param name="elementName">The name of the unknown subelement. + </param><param name="reader">The <see cref="T:System.Xml.XmlReader"/> being used for deserialization. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element identified by <paramref name="elementName"/> is locked. + - or - + One or more of the element's attributes is locked. + - or - + <paramref name="elementName"/> is unrecognized, or the element has an unrecognized attribute. + - or - + The element has a Boolean attribute with an invalid value. + - or - + An attempt was made to deserialize a property more than once. + - or - + An attempt was made to deserialize a property that is not a valid member of the element. + - or - + The element cannot contain a CDATA or text element. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ParameterElement.Name"> + <summary> + Name of this parameter. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ParameterElement.TypeName"> + <summary> + Type of this parameter. + </summary> + <remarks>This is only needed in order to disambiguate method overloads. Normally + the parameter name is sufficient.</remarks> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ParameterElement.Value"> + <summary> + Element that describes the value for this property. + </summary> + <remarks> + This is NOT marked as a ConfigurationProperty because this + child element is polymorphic, and the element tag determines + the type. Standard configuration properties only let you do + this if it's a collection, but we only want one value. Thus + the separate property. The element is deserialized in + <see cref="M:Microsoft.Practices.Unity.Configuration.ParameterElement.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"/>.</remarks> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ParameterElement.DestinationName"> + <summary> + A string describing where the value this element contains + is being used. For example, if setting a property Prop1, + this should return "property Prop1" (in english). + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ParameterElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterElement"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ParameterValueElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.ParameterValueElement"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterValueElementCollection.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Causes the configuration system to throw an exception. + </summary> + <returns> + true if the unrecognized element was deserialized successfully; otherwise, false. The default is false. + </returns> + <param name="elementName">The name of the unrecognized element. + </param><param name="reader">An input stream that reads XML from the configuration file. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element specified in <paramref name="elementName"/> is the <clear> element. + </exception><exception cref="T:System.ArgumentException"><paramref name="elementName"/> starts with the reserved prefix "config" or "lock". + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterValueElementCollection.CreateNewElement"> + <summary> + When overridden in a derived class, creates a new <see cref="T:System.Configuration.ConfigurationElement"/>. + </summary> + <returns> + A new <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ParameterValueElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ParameterValueElementCollection.DeserializedElementHolder.Value"> + <summary> + String that will be deserialized to provide the value. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ParameterValueElementCollection.DeserializedElementHolder.DestinationName"> + <summary> + A string describing where the value this element contains + is being used. For example, if setting a property Prop1, + this should return "property Prop1" (in english). + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.Properties.Resources"> + <summary> + A strongly-typed resource class, for looking up localized strings, etc. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ResourceManager"> + <summary> + Returns the cached ResourceManager instance used by this class. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.Culture"> + <summary> + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.CannotCreateContainerConfiguringElement"> + <summary> + Looks up a localized string similar to An abstract ContainerConfiguringElement cannot be created. Please specify a concrete type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.CannotCreateExtensionConfigurationElement"> + <summary> + Looks up a localized string similar to An abstract ExtensionConfigurationElement object cannot be created. Please specify a concrete type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.CannotCreateInjectionMemberElement"> + <summary> + Looks up a localized string similar to An abstract InjectionMemberElement object cannot be created. Please specify a concrete type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.CannotCreateParameterValueElement"> + <summary> + Looks up a localized string similar to An abstract ParameterValueElement object cannot be created. Please specify a concrete type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.CouldNotResolveType"> + <summary> + Looks up a localized string similar to The type name or alias {0} could not be resolved. Please check your configuration file and verify this type name.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.DependencyForGenericParameterWithTypeSet"> + <summary> + Looks up a localized string similar to The dependency element for generic parameter {0} must not have an explicit type name but has '{1}'.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.DependencyForOptionalGenericParameterWithTypeSet"> + <summary> + Looks up a localized string similar to The optional dependency element for generic parameter {0} must not have an explicit type name but has '{1}'.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.DestinationNameFormat"> + <summary> + Looks up a localized string similar to {0} {1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.DuplicateParameterValueElement"> + <summary> + Looks up a localized string similar to The injection configuration for {0} has multiple values.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ElementTypeNotRegistered"> + <summary> + Looks up a localized string similar to The configuration element type {0} has not been registered with the section.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ElementWithAttributesAndParameterValueElements"> + <summary> + Looks up a localized string similar to The injection configuration for {0} is specified through both attributes and child value elements.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ExtensionTypeNotFound"> + <summary> + Looks up a localized string similar to Could not load section extension type {0}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ExtensionTypeNotValid"> + <summary> + Looks up a localized string similar to The extension type {0} does not derive from SectionExtension.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.InvalidExtensionElementType"> + <summary> + Looks up a localized string similar to The extension element type {0} that is being added does not derive from ContainerConfiguringElement, InjectionMemberElement, or ParameterValueElement. An extension element must derive from one of these types.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.InvalidValueAttributes"> + <summary> + Looks up a localized string similar to No valid attributes were found to construct the value for the {0}. Please check the configuration file.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.NoMatchingConstructor"> + <summary> + Looks up a localized string similar to Configuration is incorrect, the type {0} does not have a constructor that takes parameters named {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.NoMatchingMethod"> + <summary> + Looks up a localized string similar to Configuration is incorrect, the type {0} does not have a method named {1} that takes parameters named {2}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.NoSuchContainer"> + <summary> + Looks up a localized string similar to The container named "{0}" is not defined in this configuration section.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.NoSuchProperty"> + <summary> + Looks up a localized string similar to The type {0} does not have a property named {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.NotAnArray"> + <summary> + Looks up a localized string similar to The configuration is set to inject an array, but the type {0} is not an array type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.Parameter"> + <summary> + Looks up a localized string similar to parameter. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.Property"> + <summary> + Looks up a localized string similar to property. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.RequiredPropertyMissing"> + <summary> + Looks up a localized string similar to The attribute {0} must be present and non-empty.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ValueNotAllowedForGenericArrayType"> + <summary> + Looks up a localized string similar to The value element for {1} was specified for the generic array type {0}. Value elements are not allowed for generic array types.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ValueNotAllowedForGenericParameterType"> + <summary> + Looks up a localized string similar to The value element for {1} was specified for the generic parameter type {0}. Value elements are not allowed for generic parameter types.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.Properties.Resources.ValueNotAllowedForOpenGenericType"> + <summary> + Looks up a localized string similar to The value element for {1} was specified for the generic type {0}. Value elements are not allowed for generic types.. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.PropertyElement"> + <summary> + A class representing a property configuration element. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.PropertyElement.#ctor"> + <summary> + Construct a new instance of <see cref="T:Microsoft.Practices.Unity.Configuration.PropertyElement"/> + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.PropertyElement.DeserializeElement(System.Xml.XmlReader,System.Boolean)"> + <summary> + Reads XML from the configuration file. + </summary> + <param name="reader">The <see cref="T:System.Xml.XmlReader"/> that reads from the configuration file. + </param><param name="serializeCollectionKey">true to serialize only the collection key properties; otherwise, false. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element to read is locked. + - or - + An attribute of the current node is not recognized. + - or - + The lock status of the current node cannot be determined. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.PropertyElement.OnDeserializeUnrecognizedAttribute(System.String,System.String)"> + <summary> + Gets a value indicating whether an unknown attribute is encountered during deserialization. + </summary> + <returns> + true when an unknown attribute is encountered while deserializing; otherwise, false. + </returns> + <param name="name">The name of the unrecognized attribute. + </param><param name="value">The value of the unrecognized attribute. + </param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.PropertyElement.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Gets a value indicating whether an unknown element is encountered during deserialization. + </summary> + <returns> + true when an unknown element is encountered while deserializing; otherwise, false. + </returns> + <param name="elementName">The name of the unknown subelement. + </param><param name="reader">The <see cref="T:System.Xml.XmlReader"/> being used for deserialization. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element identified by <paramref name="elementName"/> is locked. + - or - + One or more of the element's attributes is locked. + - or - + <paramref name="elementName"/> is unrecognized, or the element has an unrecognized attribute. + - or - + The element has a Boolean attribute with an invalid value. + - or - + An attempt was made to deserialize a property more than once. + - or - + An attempt was made to deserialize a property that is not a valid member of the element. + - or - + The element cannot contain a CDATA or text element. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.PropertyElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.PropertyElement.GetInjectionMembers(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,System.String)"> + <summary> + Return the set of <see cref="T:Microsoft.Practices.Unity.InjectionMember"/>s that are needed + to configure the container according to this configuration element. + </summary> + <param name="container">Container that is being configured.</param> + <param name="fromType">Type that is being registered.</param> + <param name="toType">Type that <paramref name="fromType"/> is being mapped to.</param> + <param name="name">Name this registration is under.</param> + <returns>One or more <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects that should be + applied to the container registration.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.PropertyElement.Name"> + <summary> + Name of the property that will be set. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.PropertyElement.Key"> + <summary> + Each element must have a unique key, which is generated by the subclasses. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.PropertyElement.Value"> + <summary> + String that will be deserialized to provide the value. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.PropertyElement.DestinationName"> + <summary> + A string describing where the value this element contains + is being used. For example, if setting a property Prop1, + this should return "property Prop1" (in english). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.PropertyElement.ElementName"> + <summary> + Element name to use to serialize this into XML. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.RegisterElement"> + <summary> + A configuration element representing a single container type registration. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.RegisterElement.ConfigureContainer(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Apply the registrations from this element to the given container. + </summary> + <param name="container">Container to configure.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.RegisterElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.RegisterElement.TypeName"> + <summary> + The type that is registered. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.RegisterElement.Name"> + <summary> + Name registered under. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.RegisterElement.MapToName"> + <summary> + Type that is mapped to. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.RegisterElement.Lifetime"> + <summary> + Lifetime manager to register for this registration. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.RegisterElement.InjectionMembers"> + <summary> + Any injection members (constructor, properties, etc.) that are specified for + this registration. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.RegisterElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.RegisterElement"/>s. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.RegisterElementCollection.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Causes the configuration system to throw an exception. + </summary> + <returns> + true if the unrecognized element was deserialized successfully; otherwise, false. The default is false. + </returns> + <param name="elementName">The name of the unrecognized element. + </param><param name="reader">An input stream that reads XML from the configuration file. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element specified in <paramref name="elementName"/> is the <clear> element. + </exception><exception cref="T:System.ArgumentException"><paramref name="elementName"/> starts with the reserved prefix "config" or "lock". + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.RegisterElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.SectionExtension"> + <summary> + Base class for Unity configuration section extensions. + Derived classes are used to add custom elments and aliases + into the configuration section being loaded. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtension.AddExtensions(Microsoft.Practices.Unity.Configuration.SectionExtensionContext)"> + <summary> + Add the extensions to the section via the context. + </summary> + <param name="context">Context object that can be used to add elements and aliases.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.SectionExtensionContext"> + <summary> + An object that gives the ability to add + elements and aliases to a configuration section. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtensionContext.AddAlias(System.String,System.Type)"> + <summary> + Add a new alias to the configuration section. This is useful + for those extensions that add commonly used types to configuration + so users don't have to alias them repeatedly. + </summary> + <param name="newAlias">The alias to use.</param> + <param name="aliasedType">Type the alias maps to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtensionContext.AddAlias``1(System.String)"> + <summary> + Add a new alias to the configuration section. This is useful + for those extensions that add commonly used types to configuration + so users don't have to alias them repeatedly. + </summary> + <typeparam name="TAliased">Type the alias maps to.</typeparam> + <param name="alias">The alias to use</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtensionContext.AddElement(System.String,System.Type)"> + <summary> + Add a new element to the configuration section schema. + </summary> + <param name="tag">Tag name in the XML.</param> + <param name="elementType">Type the tag maps to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtensionContext.AddElement``1(System.String)"> + <summary> + Add a new element to the configuration section schema. + </summary> + <typeparam name="TElement">Type the tag maps to.</typeparam> + <param name="tag">Tag name in the XML.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.SectionExtensionElement"> + <summary> + A configuration element used to specify which extensions to + add to the configuration schema. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtensionElement.DeserializeElement(System.Xml.XmlReader,System.Boolean)"> + <summary> + Reads XML from the configuration file. + </summary> + <param name="reader">The <see cref="T:System.Xml.XmlReader"/> that reads from the configuration file. + </param><param name="serializeCollectionKey">true to serialize only the collection key properties; otherwise, false. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element to read is locked. + - or - + An attribute of the current node is not recognized. + - or - + The lock status of the current node cannot be determined. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtensionElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.SectionExtensionElement.TypeName"> + <summary> + Type of the section extender object that will provide new elements to the schema. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.SectionExtensionElement.Prefix"> + <summary> + Optional prefix that will be added to the element names added by this + section extender. If left out, no prefix will be added. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.SectionExtensionElement.ExtensionObject"> + <summary> + The extension object represented by this element. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.SectionExtensionElementCollection"> + <summary> + A collection of <see cref="T:Microsoft.Practices.Unity.Configuration.SectionExtensionElement"/>s. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.SectionExtensionElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolver"> + <summary> + Type that manage access to a set of type aliases and implements + the logic for converting aliases to their actual types. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolver.SetAliases(Microsoft.Practices.Unity.Configuration.UnityConfigurationSection)"> + <summary> + Set the set of aliases to use for resolution. + </summary> + <param name="section">Configuration section containing the various + type aliases, namespaces and assemblies.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolver.ResolveType(System.String)"> + <summary> + Resolves a type alias or type fullname to a concrete type. + </summary> + <param name="typeNameOrAlias">Type alias or type fullname</param> + <returns>Type object or null if resolve fails.</returns> + <exception cref="T:System.InvalidOperationException">Thrown if alias lookup fails.</exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolver.ResolveType(System.String,System.Boolean)"> + <summary> + Resolves a type alias or type fullname to a concrete type. + </summary> + <param name="typeNameOrAlias">Alias or name to resolve.</param> + <param name="throwIfResolveFails">if true and the alias does not + resolve, throw an <see cref="T:System.InvalidOperationException"/>, otherwise + return null on failure.</param> + <returns>The type object or null if resolve fails and + <paramref name="throwIfResolveFails"/> is false.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolver.ResolveTypeWithDefault(System.String,System.Type)"> + <summary> + Resolve a type alias or type full name to a concrete type. + If <paramref name="typeNameOrAlias"/> is null or empty, return the + given <paramref name="defaultValue"/> instead. + </summary> + <param name="typeNameOrAlias">Type alias or full name to resolve.</param> + <param name="defaultValue">Value to return if typeName is null or empty.</param> + <returns>The concrete <see cref="T:System.Type"/>.</returns> + <exception cref="T:System.InvalidOperationException">Thrown if alias lookup fails.</exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolver.ResolveTypeWithDefault(System.String,System.Type,System.Boolean)"> + <summary> + Resolve a type alias or type full name to a concrete type. + If <paramref name="typeNameOrAlias"/> is null or empty, return the + given <paramref name="defaultValue"/> instead. + </summary> + <param name="typeNameOrAlias">Type alias or full name to resolve.</param> + <param name="defaultValue">Value to return if typeName is null or empty.</param> + <param name="throwIfResolveFails">if true and the alias does not + resolve, throw an <see cref="T:System.InvalidOperationException"/>, otherwise + return null on failure.</param> + <returns>The concrete <see cref="T:System.Type"/>.</returns> + <exception cref="T:System.InvalidOperationException">Thrown if alias lookup fails and + <paramref name="throwIfResolveFails"/> is true.</exception> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolverImpl"> + <summary> + A helper class that implements the actual logic for resolving a shorthand + type name (alias or raw type name) into an actual type object. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolverImpl.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.String}},System.Collections.Generic.IEnumerable{System.String},System.Collections.Generic.IEnumerable{System.String})"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolverImpl"/> that uses the given + sequence of alias, typename pairs to resolve types. + </summary> + <param name="aliasesSequence">Type aliases from the configuration file.</param> + <param name="assemblies">Assembly names to search.</param> + <param name="namespaces">Namespaces to search.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolverImpl.ResolveType(System.String,System.Boolean)"> + <summary> + Resolves a type alias or type fullname to a concrete type. + </summary> + <param name="typeNameOrAlias">Alias or name to resolve.</param> + <param name="throwIfResolveFails">if true and the alias does not + resolve, throw an <see cref="T:System.InvalidOperationException"/>, otherwise + return null on failure.</param> + <returns>The type object or null if resolve fails and + <paramref name="throwIfResolveFails"/> is false.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ConfigurationHelpers.TypeResolverImpl.ResolveTypeWithDefault(System.String,System.Type,System.Boolean)"> + <summary> + Resolve a type alias or type full name to a concrete type. + If <paramref name="typeNameOrAlias"/> is null or empty, return the + given <paramref name="defaultValue"/> instead. + </summary> + <param name="typeNameOrAlias">Type alias or full name to resolve.</param> + <param name="defaultValue">Value to return if typeName is null or empty.</param> + <param name="throwIfResolveFails">if true and the alias does not + resolve, throw an <see cref="T:System.InvalidOperationException"/>, otherwise + return null on failure.</param> + <returns> + <para>If <paramref name="typeNameOrAlias"/> is null or an empty string, + then return <paramref name="defaultValue"/>.</para> + <para>Otherwise, return the resolved type object. If the resolution fails + and <paramref name="throwIfResolveFails"/> is false, then return null.</para> + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection"> + <summary> + A configuration section describing configuration for an <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/>. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.SectionName"> + <summary> + The name of the section where unity configuration is expected to be found. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.XmlNamespace"> + <summary> + XML Namespace string used for IntelliSense in this section. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.Configure(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Apply the configuration in the default container element to the given container. + </summary> + <param name="container">Container to configure.</param> + <returns>The passed in <paramref name="container"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.Configure(Microsoft.Practices.Unity.IUnityContainer,System.String)"> + <summary> + Apply the configuration in the default container element to the given container. + </summary> + <param name="container">Container to configure.</param> + <param name="configuredContainerName">Name of the container element to use to configure the container.</param> + <returns>The passed in <paramref name="container"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.DeserializeSection(System.Xml.XmlReader)"> + <summary> + Reads XML from the configuration file. + </summary> + <param name="reader">The <see cref="T:System.Xml.XmlReader"/> object, which reads from the configuration file. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException"><paramref name="reader"/> found no elements in the configuration file. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.OnDeserializeUnrecognizedElement(System.String,System.Xml.XmlReader)"> + <summary> + Gets a value indicating whether an unknown element is encountered during deserialization. + </summary> + <returns> + true when an unknown element is encountered while deserializing; otherwise, false. + </returns> + <param name="elementName">The name of the unknown subelement. + </param><param name="reader">The <see cref="T:System.Xml.XmlReader"/> being used for deserialization. + </param><exception cref="T:System.Configuration.ConfigurationErrorsException">The element identified by <paramref name="elementName"/> is locked. + - or - + One or more of the element's attributes is locked. + - or - + <paramref name="elementName"/> is unrecognized, or the element has an unrecognized attribute. + - or - + The element has a Boolean attribute with an invalid value. + - or - + An attempt was made to deserialize a property more than once. + - or - + An attempt was made to deserialize a property that is not a valid member of the element. + - or - + The element cannot contain a CDATA or text element. + </exception> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.SerializeSection(System.Configuration.ConfigurationElement,System.String,System.Configuration.ConfigurationSaveMode)"> + <summary> + Creates an XML string containing an unmerged view of the <see cref="T:System.Configuration.ConfigurationSection"/> object as a single section to write to a file. + </summary> + <returns> + An XML string containing an unmerged view of the <see cref="T:System.Configuration.ConfigurationSection"/> object. + </returns> + <param name="parentElement">The <see cref="T:System.Configuration.ConfigurationElement"/> instance to use as the parent when performing the un-merge. + </param><param name="name">The name of the section to create. + </param><param name="saveMode">The <see cref="T:System.Configuration.ConfigurationSaveMode"/> instance to use when writing to a string. + </param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.CurrentSection"> + <summary> + The current <see cref="T:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection"/> that is being deserialized + or being configured from. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.Xmlns"> + <summary> + Storage for XML namespace. The namespace isn't used or validated by config, but + it is useful for Visual Studio XML IntelliSense to kick in. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.Containers"> + <summary> + The set of containers defined in this configuration section. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.TypeAliases"> + <summary> + The set of type aliases defined in this configuration file. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.SectionExtensions"> + <summary> + Any schema extensions that are added. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.Namespaces"> + <summary> + Any namespaces added to the type search list. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.Assemblies"> + <summary> + Any assemblies added to the type search list. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.ExtensionContext.AddAlias(System.String,System.Type)"> + <summary> + Add a new alias to the configuration section. This is useful + for those extensions that add commonly used types to configuration + so users don't have to alias them repeatedly. + </summary> + <param name="newAlias">The alias to use.</param> + <param name="aliasedType">Type the alias maps to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityConfigurationSection.ExtensionContext.AddElement(System.String,System.Type)"> + <summary> + Add a new element to the configuration section schema. + </summary> + <param name="tag">Tag name in the XML.</param> + <param name="elementType">Type the tag maps to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ContainerElementCollection"> + <summary> + Collection element for <see cref="T:Microsoft.Practices.Unity.Configuration.ContainerElement"/>s. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerElementCollection.GetElement(System.Int32)"> + <summary> + Plug point to get objects out of the collection. + </summary> + <param name="index">Index in the collection to retrieve the item from.</param> + <returns>Item at that index or null if not present.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerElementCollection.GetElement(System.Object)"> + <summary> + Plug point to get objects out of the collection. + </summary> + <param name="key">Key to look up the object by.</param> + <returns>Item with that key or null if not present.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ContainerElementCollection.GetElementKey(System.Configuration.ConfigurationElement)"> + <summary> + Gets the element key for a specified configuration element when overridden in a derived class. + </summary> + <returns> + An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>. + </returns> + <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for. + </param> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerElementCollection.Item(System.String)"> + <summary> + Retrieve a stored <see cref="T:Microsoft.Practices.Unity.Configuration.ContainerElement"/> by name. + </summary> + <param name="name">Name to look up.</param> + <returns>The stored container or null if not in the collection.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ContainerElementCollection.Default"> + <summary> + Return the default container in the collection. The default is the one without a name. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.UnityContainerExtensions"> + <summary> + Extensions to <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> to simplify + loading configuration into a container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityContainerExtensions.LoadConfiguration(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,System.String)"> + <summary> + Apply configuration from the given section and named container + into the given container. + </summary> + <param name="container">Unity container to configure.</param> + <param name="section">Configuration section with config information.</param> + <param name="containerName">Named container.</param> + <returns><paramref name="container"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityContainerExtensions.LoadConfiguration(Microsoft.Practices.Unity.IUnityContainer,System.String)"> + <summary> + Apply configuration from the default section (named "unity" pulled out of + ConfigurationManager) and the named container. + </summary> + <param name="container">Unity container to configure.</param> + <param name="containerName">Named container element in configuration.</param> + <returns><paramref name="container"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityContainerExtensions.LoadConfiguration(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Apply configuration from the default section and unnamed container element. + </summary> + <param name="container">Container to configure.</param> + <returns><paramref name="container"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.UnityContainerExtensions.LoadConfiguration(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.Configuration.UnityConfigurationSection)"> + <summary> + Apply configuration from the default container in the given section. + </summary> + <param name="container">Unity container to configure.</param> + <param name="section">Configuration section.</param> + <returns><paramref name="container"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Configuration.ValueElement"> + <summary> + Element that describes a constant value that will be + injected into the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ValueElement.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.Configuration.ValueElement"/> object. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ValueElement.#ctor(System.Collections.Generic.IDictionary{System.String,System.String})"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.Configuration.ValueElement"/> object, + initializing properties from the contents of + <paramref name="propertyValues"/>. + </summary> + <param name="propertyValues">Name/value pairs which + contain the values to initialize properties to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ValueElement.Microsoft#Practices#Unity#Configuration#IAttributeOnlyElement#SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. + </summary> + <remarks>The caller of this method has already written the start element tag before + calling this method, so deriving classes only need to write the element content, not + the start or end tags.</remarks> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ValueElement.SerializeContent(System.Xml.XmlWriter)"> + <summary> + Write the contents of this element to the given <see cref="T:System.Xml.XmlWriter"/>. This + method always outputs an explicit <dependency> tag, instead of providing + attributes to the parent method. + </summary> + <param name="writer">Writer to send XML content to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Configuration.ValueElement.GetInjectionParameterValue(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Generate an <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object + that will be used to configure the container for a type registration. + </summary> + <param name="container">Container that is being configured. Supplied in order + to let custom implementations retrieve services; do not configure the container + directly in this method.</param> + <param name="parameterType">Type of the parameter to get the value for.</param> + <returns>The required <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ValueElement.Value"> + <summary> + Value for this element + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Configuration.ValueElement.TypeConverterTypeName"> + <summary> + + </summary> + </member> + </members> +</doc>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Unity.3.0.1304.1/lib/Net45/Microsoft.Practices.Unity.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,6179 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>Microsoft.Practices.Unity</name> + </assembly> + <members> + <member name="T:Microsoft.Practices.Unity.DuplicateTypeMappingException"> + <summary> + The exception that is thrown when registering multiple types would result in an type mapping being overwritten. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DuplicateTypeMappingException.#ctor(System.String,System.Type,System.Type,System.Type)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.Unity.DuplicateTypeMappingException"/> class. + </summary> + <param name="name">The name for the mapping.</param> + <param name="mappedFromType">The source type for the mapping.</param> + <param name="currentMappedToType">The type currently mapped.</param> + <param name="newMappedToType">The new type to map.</param> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.Name"> + <summary> + Gets the name for the mapping. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.MappedFromType"> + <summary> + Gets the source type for the mapping. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.CurrentMappedToType"> + <summary> + Gets the type currently mapped. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.NewMappedToType"> + <summary> + Gets the new type to map. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.WithLifetime"> + <summary> + Provides helper methods to specify the lifetime for a type with registration by convention. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.None(System.Type)"> + <summary> + Returns a <see langword="null"/> <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A lifetime manager</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.ContainerControlled(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A container controlled lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.ExternallyControlled(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>An externally controlled lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Hierarchical(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.HierarchicalLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A hierarchical lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.PerResolve(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A per resolve lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Transient(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.TransientLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A transient lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Custom``1(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="T">The custom <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> type.</typeparam> + <param name="type">The type.</param> + <returns> + A lifetime manager. + </returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.PerThread(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.PerThreadLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A per thread lifetime manager.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.AllClasses"> + <summary> + Provides helper methods to retrieve classes from assemblies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Reflection.Assembly[])"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>. + </summary> + <param name="assemblies">The assemblies.</param> + <returns>All visible, non-abstract classes found in the assemblies.</returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks>All exceptions thrown while getting types from the assemblies are ignored, and the types that can be retrieved are returned.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Boolean,System.Reflection.Assembly[])"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>, and optionally skips errors. + </summary> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <param name="assemblies">The assemblies.</param> + <returns> + All visible, non-abstract classes. + </returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Collections.Generic.IEnumerable{System.Reflection.Assembly},System.Boolean)"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>. + </summary> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <param name="assemblies">The assemblies.</param> + <returns> + All visible, non-abstract classes. + </returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromLoadedAssemblies(System.Boolean,System.Boolean,System.Boolean,System.Boolean)"> + <summary> + Returns all visible, non-abstract classes from all assemblies that are loaded in the current application domain. + </summary> + <param name="includeSystemAssemblies"><see langword="false" /> to include system assemblies; otherwise, <see langword="false" />. Defaults to <see langword="false" />.</param> + <param name="includeUnityAssemblies"><see langword="false" /> to include the Unity assemblies; otherwise, <see langword="false" />. Defaults to <see langword="false" />.</param> + <param name="includeDynamicAssemblies"><see langword="false" /> to include dynamic assemblies; otherwise, <see langword="false" />. Defaults to <see langword="false" />.</param> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <returns> + All visible, non-abstract classes in the loaded assemblies. + </returns> + <remarks> + If <paramref name="skipOnError" /> is <see langword="true" />, all exceptions thrown while getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssembliesInBasePath(System.Boolean,System.Boolean,System.Boolean)"> + <summary> + Returns all visible, non-abstract classes from all assemblies that are located in the base folder of the current application domain. + </summary> + <param name="includeSystemAssemblies"><see langword="false" /> to include system assemblies; otherwise, <see langword="false" />. Defaults to <see langword="false" />.</param> + <param name="includeUnityAssemblies"><see langword="false" /> to include the Unity assemblies; otherwise, <see langword="false" />. Defaults to <see langword="false" />.</param> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <returns> + All visible, non-abstract classes. + </returns> + <remarks> + If <paramref name="skipOnError" /> is <see langword="true" />, all exceptions thrown while loading assemblies or getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.RegistrationConvention"> + <summary> + Represents a set of types to register and their registration settings. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetTypes"> + <summary> + Gets types to register. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetFromTypes"> + <summary> + Gets a function to get the types that will be requested for each type to configure. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetName"> + <summary> + Gets a function to get the name to use for the registration of each type. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetLifetimeManager"> + <summary> + Gets a function to get the <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the registration of each type. Defaults to no lifetime management. + </summary> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetInjectionMembers"> + <summary> + Gets a function to get the additional <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects for the registration of each type. Defaults to no injection members. + </summary> + <returns></returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithName"> + <summary> + Provides helper methods to get type names. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithName.TypeName(System.Type)"> + <summary> + Returns the type name. + </summary> + <param name="type">The type.</param> + <returns>The type name.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithName.Default(System.Type)"> + <summary> + Returns null for the registration name. + </summary> + <param name="type">The type.</param> + <returns><see langword="null"/></returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithMappings"> + <summary> + Provides helper methods to map types to the types interfaces to which register them. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.None(System.Type)"> + <summary> + Returns no types. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An empty enumeration.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromMatchingInterface(System.Type)"> + <summary> + Returns an enumeration with the interface that matches the name of <paramref name="implementationType"/>. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with the first interface matching the name of <paramref name="implementationType"/> (for example, if type is MyType, a matching interface is IMyType), + or an empty enumeration if no such interface is found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromAllInterfaces(System.Type)"> + <summary> + Returns an enumeration with all the interfaces implemented by <paramref name="implementationType"/>. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with all the interfaces implemented by the implementation type except <see cref="T:System.IDisposable"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromAllInterfacesInSameAssembly(System.Type)"> + <summary> + Returns an enumeration with all the interfaces implemented by <paramref name="implementationType"/> that belong to the same assembly as implementationType. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with all the interfaces implemented by the implementation type that belong to the same assembly.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions"> + <summary> + Provides a set of convenience overloads to the + <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> interface to support registration of multiple types. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions.RegisterTypes(Microsoft.Practices.Unity.IUnityContainer,System.Collections.Generic.IEnumerable{System.Type},System.Func{System.Type,System.Collections.Generic.IEnumerable{System.Type}},System.Func{System.Type,System.String},System.Func{System.Type,Microsoft.Practices.Unity.LifetimeManager},System.Func{System.Type,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionMember}},System.Boolean)"> + <summary> + Registers the supplied types by using the specified rules for name, lifetime manager, injection members, and registration types. + </summary> + <param name="container">The container to configure.</param> + <param name="types">The types to register. The methods in the <see cref="T:Microsoft.Practices.Unity.AllClasses"/> class can be used to scan assemblies to get types, and further filtering can be performed using LINQ queries.</param> + <param name="getFromTypes">A function that gets the types that will be requested for each type to configure. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithMappings"/> class or a custom function. Defaults to no registration types, and registers only the supplied types.</param> + <param name="getName">A function that gets the name to use for the registration of each type. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithName"/> or a custom function. Defaults to no name.</param> + <param name="getLifetimeManager">A function that gets the <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the registration of each type. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithLifetime"/> class or a custom function. Defaults to no lifetime management.</param> + <param name="getInjectionMembers">A function that gets the additional <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects for the registration of each type. Defaults to no injection members.</param> + <param name="overwriteExistingMappings"><see langword="true"/> to overwrite existing mappings; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <returns> + The container that this method was called on. + </returns> + <exception cref="T:System.ArgumentException">A new registration would overwrite an existing mapping and <paramref name="overwriteExistingMappings"/> is <see langword="false"/>.</exception> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions.RegisterTypes(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.RegistrationConvention,System.Boolean)"> + <summary> + Registers the types according to the <paramref name="convention"/>. + </summary> + <param name="container">The container to configure.</param> + <param name="convention">The convention to determine which types will be registered and how.</param> + <param name="overwriteExistingMappings"><see langword="true"/> to overwrite existing mappings; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <returns> + The container that this method was called on. + </returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LazyDynamicMethodBuildPlanCreatorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"/> implementation + that constructs a build plan for creating <see cref="T:System.Lazy`1"/> objects. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that can create and return an <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy"/> + for the given build key. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"> + <summary> + Represents a builder policy interface. Since there are no fixed requirements + for policies, it acts as a marker interface from which to derive all other + policy interfaces. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Create a build plan using the given context and build key. + </summary> + <param name="context">Current build context.</param> + <param name="buildKey">Current build key.</param> + <returns>The build plan.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LazyDynamicMethodBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Creates a build plan using the given context and build key. + </summary> + <param name="context">Current build context.</param> + <param name="buildKey">Current build key.</param> + <returns> + The build plan. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions"> + <summary> + Provides extension methods to the <see cref="T:System.Type"/> class due to the introduction + of <see cref="T:System.Reflection.TypeInfo"/> class in the .NET for Windows Store apps. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetConstructor(System.Type,System.Type[])"> + <summary> + Returns the constructor in <paramref name="type"/> that matches the specified constructor parameter types. + </summary> + <param name="type">The type to inspect</param> + <param name="constructorParameters">The constructor parameter types.</param> + <returns>The constructor that matches the specified parameter types.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetMethodsHierarchical(System.Type)"> + <summary> + Returns the non-static declared methods of a type or its base types. + </summary> + <param name="type">The type to inspect</param> + <returns>An enumerable of the <see cref="T:System.Reflection.MethodInfo"/> objects.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetMethodHierarchical(System.Type,System.String,System.Type[])"> + <summary> + Returns the non-static method of a type or its based type. + </summary> + <param name="type">The type to inspect</param> + <param name="methodName">The name of the method to seek.</param> + <param name="closedParameters">The (closed) parameter type signature of the method.</param> + <returns>The discovered <see cref="T:System.Reflection.MethodInfo"/></returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetPropertiesHierarchical(System.Type)"> + <summary> + Returns the declared properties of a type or its base types. + </summary> + <param name="type">The type to inspect</param> + <returns>An enumerable of the <see cref="T:System.Reflection.PropertyInfo"/> objects.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.ParametersMatch(System.Reflection.ParameterInfo[],System.Type[])"> + <summary> + Determines if the types in a parameter set ordinally matches the set of supplied types. + </summary> + <param name="parameters"></param> + <param name="closedConstructorParameterTypes"></param> + <returns></returns> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyResolutionAttribute"> + <summary> + Base class for attributes that can be placed on parameters + or properties to specify how to resolve the value for + that parameter or property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyResolutionAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionConstructorAttribute"> + <summary> + This attribute is used to indicate which constructor to choose when + the container attempts to build a type. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMethodAttribute"> + <summary> + This attribute is used to mark methods that should be called when + the container is building an object. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyAttribute"> + <summary> + This attribute is used to mark properties and parameters as targets for injection. + </summary> + <remarks> + For properties, this attribute is necessary for injection to happen. For parameters, + it's not needed unless you want to specify additional information to control how + the parameter is resolved. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.#ctor"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> with no name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.#ctor(System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> with the given name. + </summary> + <param name="name">Name to use when resolving this dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.DependencyAttribute.Name"> + <summary> + The name specified in the constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.DependencyResolutionAttribute"/> used to mark a dependency + as optional - the container will try to resolve it, and return null + if the resolution fails rather than throw. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"/> object. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"/> object that + specifies a named dependency. + </summary> + <param name="name">Name of the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyAttribute.Name"> + <summary> + Name of the dependency. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.CompositeResolverOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that composites other + ResolverOverride objects. The GetResolver operation then + returns the resolver from the first child override that + matches the current context and request. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ResolverOverride"> + <summary> + Base class for all override objects passed in the + <see cref="M:Microsoft.Practices.Unity.IUnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"/> method. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.OnType``1"> + <summary> + Wrap this resolver in one that verifies the type of the object being built. + This allows you to narrow any override down to a specific type easily. + </summary> + <typeparam name="T">Type to constrain the override to.</typeparam> + <returns>The new override.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.OnType(System.Type)"> + <summary> + Wrap this resolver in one that verifies the type of the object being built. + This allows you to narrow any override down to a specific type easily. + </summary> + <param name="typeToOverride">Type to constrain the override to.</param> + <returns>The new override.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.Add(Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> to the collection + that is checked. + </summary> + <param name="newOverride">item to add.</param> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.AddRange(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a setof <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>s to the collection. + </summary> + <param name="newOverrides">items to add.</param> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ContainerRegistration"> + <summary> + Class that returns information about the types registered in a container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.RegisteredType"> + <summary> + The type that was passed to the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> method + as the "from" type, or the only type if type mapping wasn't done. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.MappedToType"> + <summary> + The type that this registration is mapped to. If no type mapping was done, the + <see cref="P:Microsoft.Practices.Unity.ContainerRegistration.RegisteredType"/> property and this one will have the same value. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.Name"> + <summary> + Name the type was registered under. Null for default registration. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.LifetimeManagerType"> + <summary> + The registered lifetime manager instance. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.LifetimeManager"> + <summary> + The lifetime manager for this registration. + </summary> + <remarks> + This property will be null if this registration is for an open generic.</remarks> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> class that overrides + the value injected whenever there is a dependency of the + given type, regardless of where it appears in the object graph. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride.#ctor(System.Type,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> to override + the given type with the given value. + </summary> + <param name="typeToConstruct">Type of the dependency.</param> + <param name="dependencyValue">Value to use.</param> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverride`1"> + <summary> + A convenience version of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> that lets you + specify the dependency type using generic syntax. + </summary> + <typeparam name="T">Type of the dependency to override.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride`1.#ctor(System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.DependencyOverride`1"/> object that will + override the given dependency, and pass the given value. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> that lets you + specify multiple parameter overrides in one shot rather than having + to construct multiple objects. + </summary> + <remarks> + This class isn't really a collection, it just implements IEnumerable + so that we get use of the nice C# collection initializer syntax. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.OverrideCollection`3"> + <summary> + Base helper class for creating collections of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects + for use in passing a bunch of them to the resolve call. This base class provides + the mechanics needed to allow you to use the C# collection initializer syntax. + </summary> + <typeparam name="TOverride">Concrete type of the <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> this class collects.</typeparam> + <typeparam name="TKey">Key used to create the underlying override object.</typeparam> + <typeparam name="TValue">Value that the override returns.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"> + <summary> + Add a new override to the collection with the given key and value. + </summary> + <param name="key">Key - for example, a parameter or property name.</param> + <param name="value">Value - the value to be returned by the override.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.MakeOverride(`1,`2)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverrides.MakeOverride(System.Type,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.ChildContainerCreated"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.#ctor(Microsoft.Practices.Unity.ExtensionContext)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs"/> object with the + given child container object. + </summary> + <param name="childContext">An <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> for the newly created child + container.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.ChildContainer"> + <summary> + The newly created child container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.ChildContext"> + <summary> + An extension context for the created child container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.GenericParameterBase"> + <summary> + Base class for <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> subclasses that let you specify that + an instance of a generic type parameter should be resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameterValue"> + <summary> + Base type for objects that are used to configure parameters for + constructor or method injection, or for getting the value to + be injected into a property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameters(System.Object[])"> + <summary> + Convert the given set of arbitrary values to a sequence of InjectionParameterValue + objects. The rules are: If it's already an InjectionParameterValue, return it. If + it's a Type, return a ResolvedParameter object for that type. Otherwise return + an InjectionParameter object for that value. + </summary> + <param name="values">The values to build the sequence from.</param> + <returns>The resulting converted sequence.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameter(System.Object)"> + <summary> + Convert an arbitrary value to an InjectionParameterValue object. The rules are: + If it's already an InjectionParameterValue, return it. If it's a Type, return a + ResolvedParameter object for that type. Otherwise return an InjectionParameter + object for that value. + </summary> + <param name="value">The value to convert.</param> + <returns>The resulting <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.InjectionParameterValue.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.GenericParameterBase.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalGenericParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an instance of a generic type parameter should be resolved, providing the <see langword="null"/> + value if resolving fails. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionFactory"> + <summary> + A class that lets you specify a factory method the container + will use to create the object. + </summary> + <remarks>This is a significantly easier way to do the same + thing the old static factory extension was used for.</remarks> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMember"> + <summary> + Base class for objects that can be used to configure what + class members get injected by the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMember.AddPolicies(System.Type,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="typeToCreate">Type to register.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMember.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface being registered. If no interface, + this will be null.</param> + <param name="implementationType">Type of concrete type being registered.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.#ctor(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionFactory"/> with + the given factory function. + </summary> + <param name="factoryFunc">Factory function.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.#ctor(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,System.Object})"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionFactory"/> with + the given factory function. + </summary> + <param name="factoryFunc">Factory function.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface being registered. If no interface, + this will be null. This parameter is ignored in this implementation.</param> + <param name="implementationType">Type of concrete type being registered.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that can be passed to + <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> to configure a + parameter or property as an optional dependency. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.TypedInjectionValue"> + <summary> + A base class for implementing <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> classes + that deal in explicit types. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TypedInjectionValue.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.TypedInjectionValue"/> that exposes + information about the given <paramref name="parameterType"/>. + </summary> + <param name="parameterType">Type of the parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TypedInjectionValue.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.TypedInjectionValue.ParameterType"> + <summary> + The type of parameter this object represents. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.TypedInjectionValue.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter"/> object that + specifies the given <paramref name="type"/>. + </summary> + <param name="type">Type of the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter"/> object that + specifies the given <paramref name="type"/> and <paramref name="name"/>. + </summary> + <param name="type">Type of the dependency.</param> + <param name="name">Name for the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.OptionalParameter"></see> that lets you + specify the type of the dependency using generics syntax. + </summary> + <typeparam name="T">Type of the dependency.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter`1.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter`1"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter`1.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter`1"/> with the given + <paramref name="name"/>. + </summary> + <param name="name">Name of the dependency.</param> + </member> + <member name="T:Microsoft.Practices.Unity.HierarchicalLifetimeManager"> + <summary> + A special lifetime manager which works like <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/>, + except that in the presence of child containers, each child gets it's own instance + of the object, instead of sharing one in the common parent. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that holds onto the instance given to it. + When the <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/> is disposed, + the instance is disposed with it. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.SynchronizedLifetimeManager"> + <summary> + Base class for Lifetime managers which need to synchronize calls to + <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/>. + </summary> + <remarks> + <para> + The purpose of this class is to provide a basic implementation of the lifetime manager synchronization pattern. + </para> + <para> + Calls to the <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/> method of a <see cref="T:Microsoft.Practices.Unity.SynchronizedLifetimeManager"/> + instance acquire a lock, and if the instance has not been initialized with a value yet the lock will only be released + when such an initialization takes place by calling the <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"/> method or if + the build request which resulted in the call to the GetValue method fails. + </para> + </remarks> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> + </member> + <member name="T:Microsoft.Practices.Unity.LifetimeManager"> + <summary> + Base class for Lifetime managers - classes that control how + and when instances are created by the Unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that controls how instances are + persisted and recovered from an external store. Used to implement + things like singletons and per-http-request lifetime. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object to store.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.RemoveValue"> + <summary> + Remove the value this lifetime policy is managing from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"> + <summary> + This interface provides a hook for the builder context to + implement error recovery when a builder strategy throws + an exception. Since we can't get try/finally blocks onto + the call stack for later stages in the chain, we instead + add these objects to the context. If there's an exception, + all the current IRequiresRecovery instances will have + their Recover methods called. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"> + <summary> + A method that does whatever is needed to clean up + as part of cleaning up after an exception. + </summary> + <remarks> + Don't do anything that could throw in this method, + it will cause later recover operations to get skipped + and play real havoc with the stack trace. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + <remarks>Calls to this method acquire a lock which is released only if a non-null value + has been set for the lifetime manager.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SynchronizedGetValue"> + <summary> + Performs the actual retrieval of a value from the backing store associated + with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + <remarks>This method is invoked by <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/> + after it has acquired its lock.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + <remarks>Setting a value will attempt to release the lock acquired by + <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/>.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SynchronizedSetValue(System.Object)"> + <summary> + Performs the actual storage of the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + <remarks>This method is invoked by <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"/> + before releasing its lock.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.Recover"> + <summary> + A method that does whatever is needed to clean up + as part of cleaning up after an exception. + </summary> + <remarks> + Don't do anything that could throw in this method, + it will cause later recover operations to get skipped + and play real havoc with the stack trace. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.SynchronizedGetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.SynchronizedSetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.Dispose"> + <summary> + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + </summary> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.Dispose(System.Boolean)"> + <summary> + Standard Dispose pattern implementation. Not needed, but it keeps FxCop happy. + </summary> + <param name="disposing">Always true, since we don't have a finalizer.</param> + </member> + <member name="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"> + <summary> + This is a custom lifetime manager that acts like <see cref="T:Microsoft.Practices.Unity.TransientLifetimeManager"/>, + but also provides a signal to the default build plan, marking the type so that + instances are reused across the build up object graph. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/> object that does not + itself manage an instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.#ctor(System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/> object that stores the + give value. This value will be returned by <see cref="M:Microsoft.Practices.Unity.LifetimeManager.GetValue"/> + but is not stored in the lifetime manager, nor is the value disposed. + This Lifetime manager is intended only for internal use, which is why the + normal <see cref="M:Microsoft.Practices.Unity.LifetimeManager.SetValue(System.Object)"/> method is not used here. + </summary> + <param name="value">Value to store.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. In this class, + this is a noop, since it has special hooks down in the guts. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. Noop in this class. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.HierarchicalLifetimeStrategy"> + <summary> + A strategy that handles Hierarchical lifetimes across a set of parent/child + containers. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"> + <summary> + Represents a strategy in the chain of responsibility. + Strategies are required to support both BuildUp and TearDown. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"> + <summary> + Represents a strategy in the chain of responsibility. + Strategies are required to support both BuildUp and TearDown. Although you + can implement this interface directly, you may also choose to use + <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> as the base class for your strategies, as + this class provides useful helper methods and makes support BuildUp and TearDown + optional. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PostTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PostTearDown method is called when the chain has finished the PreTearDown + phase and executes in reverse order from the PreTearDown calls. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PostTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PostTearDown method is called when the chain has finished the PreTearDown + phase and executes in reverse order from the PreTearDown calls. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.Unity.HierarchicalLifetimeStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that will attempt to + resolve a value, and return null if it cannot rather than throwing. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that is used at build plan execution time + to resolve a dependent value. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"/> object + that will attempt to resolve the given name and type from the container. + </summary> + <param name="type">Type to resolve. Must be a reference type.</param> + <param name="name">Name to resolve with.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"/> object + that will attempt to resolve the given type from the container. + </summary> + <param name="type">Type to resolve. Must be a reference type.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.DependencyType"> + <summary> + Type this resolver will resolve. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.Name"> + <summary> + Name this resolver will resolve. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions"> + <summary> + Extension methods on <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to provide convenience + overloads (generic versions, mostly). + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Clear``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <typeparam name="TPolicyInterface">The type the policy was registered as.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to remove the policy from.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.ClearDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Removes a default policy. + </summary> + <typeparam name="TPolicyInterface">The type the policy was registered as.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to remove the policy from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,System.Boolean)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean)"> + <summary> + Get the non default policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,System.Boolean)"> + <summary> + Get the non default policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Set``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,``0,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add the policy to.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.SetDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,``0)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <typeparam name="TPolicyInterface">The interface to register the policy under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add the policy to.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildOperation"> + <summary> + Base class for the current operation stored in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildOperation.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.BuildOperation"/>. + </summary> + <param name="typeBeingConstructed">Type currently being built.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuildOperation.TypeBeingConstructed"> + <summary> + The type that's currently being built. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DeferredResolveBuildPlanPolicy"> + <summary> + Build plan for <see cref="T:System.Func`1"/> that will + return a func that will resolve the requested type + through this container later. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy"> + <summary> + A build plan is an object that, when invoked, will create a new object + or fill in a given existing one. It encapsulates all the information + gathered by the strategies to construct a particular object. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.OverriddenBuildPlanMarkerPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions"> + <summary> + The almost inevitable collection of extra helper methods on + <see cref="T:System.Collections.Generic.IEnumerable`1"/> to augment the rich set of what + Linq already gives us. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})"> + <summary> + Execute the provided <paramref name="action"/> on every item in <paramref name="sequence"/>. + </summary> + <typeparam name="TItem">Type of the items stored in <paramref name="sequence"/></typeparam> + <param name="sequence">Sequence of items to process.</param> + <param name="action">Code to run over each item.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.JoinStrings``1(System.Collections.Generic.IEnumerable{``0},System.String,System.Func{``0,System.String})"> + <summary> + Create a single string from a sequenc of items, separated by the provided <paramref name="separator"/>, + and with the conversion to string done by the given <paramref name="converter"/>. + </summary> + <remarks>This method does basically the same thing as <see cref="M:System.String.Join(System.String,System.String[])"/>, + but will work on any sequence of items, not just arrays.</remarks> + <typeparam name="TItem">Type of items in the sequence.</typeparam> + <param name="sequence">Sequence of items to convert.</param> + <param name="separator">Separator to place between the items in the string.</param> + <param name="converter">The conversion function to change TItem -> string.</param> + <returns>The resulting string.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.JoinStrings``1(System.Collections.Generic.IEnumerable{``0},System.String)"> + <summary> + Create a single string from a sequenc of items, separated by the provided <paramref name="separator"/>, + and with the conversion to string done by the item's <see cref="M:System.Object.ToString"/> method. + </summary> + <remarks>This method does basically the same thing as <see cref="M:System.String.Join(System.String,System.String[])"/>, + but will work on any sequence of items, not just arrays.</remarks> + <typeparam name="TItem">Type of items in the sequence.</typeparam> + <param name="sequence">Sequence of items to convert.</param> + <param name="separator">Separator to place between the items in the string.</param> + <returns>The resulting string.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ParameterOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> class that lets you + override a named parameter passed to a constructor. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverride.#ctor(System.String,System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ParameterOverride"/> object that will + override the given named constructor parameter, and pass the given + value. + </summary> + <param name="parameterName">Name of the constructor parameter.</param> + <param name="parameterValue">Value to pass for the constructor.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ParameterOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.ParameterOverride"/> that lets you + specify multiple parameter overrides in one shot rather than having + to construct multiple objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverrides.MakeOverride(System.String,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.PropertyOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that lets you override + the value for a specified property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverride.#ctor(System.String,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.PropertyOverride"/>. + </summary> + <param name="propertyName">The property name.</param> + <param name="propertyValue">Value to use for the property.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.PropertyOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.PropertyOverride"/> that lets you + specify multiple property overrides in one shot rather than having + to construct multiple objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverrides.MakeOverride(System.String,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration"> + <summary> + Interface defining the configuration interface exposed by the + Static Factory extension. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.IUnityContainerExtensionConfigurator"> + <summary> + Base interface for all extension configuration interfaces. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainerExtensionConfigurator.Container"> + <summary> + Retrieve the container instance that we are currently configuring. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration.RegisterFactory``1(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration.RegisterFactory``1(System.String,System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/> and <paramref name="name"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="name">The name that will be used when requesting to resolve this type.</param> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"> + <summary> + Represents the context in which a build-up or tear-down operation runs. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"> + <summary> + Represents the context in which a build-up or tear-down operation runs. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.AddResolverOverrides(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a new set of resolver override objects to the current build operation. + </summary> + <param name="newOverrides"><see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.GetOverriddenResolver(System.Type)"> + <summary> + Get a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object for the given <paramref name="dependencyType"/> + or null if that dependency hasn't been overridden. + </summary> + <param name="dependencyType">Type of the dependency.</param> + <returns>Resolver to use, or null if no override matches for the current operation.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + A convenience method to do a new buildup operation on an existing context. + </summary> + <param name="newBuildKey">Key to use to build up.</param> + <returns>Created object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Action{Microsoft.Practices.ObjectBuilder2.IBuilderContext})"> + <summary> + A convenience method to do a new buildup operation on an existing context. This + overload allows you to specify extra policies which will be in effect for the duration + of the build. + </summary> + <param name="newBuildKey">Key defining what to build up.</param> + <param name="childCustomizationBlock">A delegate that takes a <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/>. This + is invoked with the new child context before the build up process starts. This gives callers + the opportunity to customize the context for the build process.</param> + <returns>Created object.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Strategies"> + <summary> + Gets the head of the strategy chain. + </summary> + <returns> + The strategy that's first in the chain; returns null if there are no + strategies in the chain. + </returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Lifetime"> + <summary> + Gets the <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </summary> + <value> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.OriginalBuildKey"> + <summary> + Gets the original build key for the build operation. + </summary> + <value> + The original build key for the build operation. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.BuildKey"> + <summary> + Get the current build key for the current build operation. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.PersistentPolicies"> + <summary> + The set of policies that were passed into this context. + </summary> + <remarks>This returns the policies passed into the context. + Policies added here will remain after buildup completes.</remarks> + <value>The persistent policies for the current context.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Policies"> + <summary> + Gets the policies for the current context. + </summary> + <remarks>Any policies added to this object are transient + and will be erased at the end of the buildup.</remarks> + <value> + The policies for the current context. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.RecoveryStack"> + <summary> + Gets the collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> objects + that need to execute in event of an exception. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Existing"> + <summary> + The current object being built up or torn down. + </summary> + <value> + The current object being manipulated by the build operation. May + be null if the object hasn't been created yet.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.BuildComplete"> + <summary> + Flag indicating if the build operation should continue. + </summary> + <value>true means that building should not call any more + strategies, false means continue to the next strategy.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.CurrentOperation"> + <summary> + An object representing what is currently being done in the + build chain. Used to report back errors if there's a failure. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.ChildContext"> + <summary> + The build context used to resolve a dependency during the build operation represented by this context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor(Microsoft.Practices.ObjectBuilder2.IStrategyChain,Microsoft.Practices.ObjectBuilder2.ILifetimeContainer,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Object)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> class with a <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>, + <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/>, <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> and the + build key used to start this build operation. + </summary> + <param name="chain">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/> to use for this context.</param> + <param name="lifetime">The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> to use for this context.</param> + <param name="policies">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to use for this context.</param> + <param name="originalBuildKey">Build key to start building.</param> + <param name="existing">The existing object to build up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor(Microsoft.Practices.ObjectBuilder2.IStrategyChain,Microsoft.Practices.ObjectBuilder2.ILifetimeContainer,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Object)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> using the explicitly provided + values. + </summary> + <param name="chain">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/> to use for this context.</param> + <param name="lifetime">The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> to use for this context.</param> + <param name="persistentPolicies">The set of persistent policies to use for this context.</param> + <param name="transientPolicies">The set of transient policies to use for this context. It is + the caller's responsibility to ensure that the transient and persistent policies are properly + combined.</param> + <param name="buildKey">Build key for this context.</param> + <param name="existing">Existing object to build up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.AddResolverOverrides(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a new set of resolver override objects to the current build operation. + </summary> + <param name="newOverrides"><see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.GetOverriddenResolver(System.Type)"> + <summary> + Get a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object for the given <paramref name="dependencyType"/> + or null if that dependency hasn't been overridden. + </summary> + <param name="dependencyType">Type of the dependency.</param> + <returns>Resolver to use, or null if no override matches for the current operation.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + A convenience method to do a new buildup operation on an existing context. + </summary> + <param name="newBuildKey">Key to use to build up.</param> + <returns>Created object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Action{Microsoft.Practices.ObjectBuilder2.IBuilderContext})"> + <summary> + A convenience method to do a new buildup operation on an existing context. This + overload allows you to specify extra policies which will be in effect for the duration + of the build. + </summary> + <param name="newBuildKey">Key defining what to build up.</param> + <param name="childCustomizationBlock">A delegate that takes a <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/>. This + is invoked with the new child context before the build up process starts. This gives callers + the opportunity to customize the context for the build process.</param> + <returns>Created object.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Strategies"> + <summary> + Gets the head of the strategy chain. + </summary> + <returns> + The strategy that's first in the chain; returns null if there are no + strategies in the chain. + </returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.BuildKey"> + <summary> + Get the current build key for the current build operation. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Existing"> + <summary> + The current object being built up or torn down. + </summary> + <value> + The current object being manipulated by the build operation. May + be null if the object hasn't been created yet.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Lifetime"> + <summary> + Gets the <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </summary> + <value> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.OriginalBuildKey"> + <summary> + Gets the original build key for the build operation. + </summary> + <value> + The original build key for the build operation. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.PersistentPolicies"> + <summary> + The set of policies that were passed into this context. + </summary> + <remarks>This returns the policies passed into the context. + Policies added here will remain after buildup completes.</remarks> + <value>The persistent policies for the current context.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Policies"> + <summary> + Gets the policies for the current context. + </summary> + <remarks> + Any modifications will be transient (meaning, they will be forgotten when + the outer BuildUp for this context is finished executing). + </remarks> + <value> + The policies for the current context. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.RecoveryStack"> + <summary> + Gets the collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> objects + that need to execute in event of an exception. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.BuildComplete"> + <summary> + Flag indicating if the build operation should continue. + </summary> + <value>true means that building should not call any more + strategies, false means continue to the next strategy.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.CurrentOperation"> + <summary> + An object representing what is currently being done in the + build chain. Used to report back errors if there's a failure. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.ChildContext"> + <summary> + The build context used to resolve a dependency during the build operation represented by this context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"> + <summary> + Represents that a dependency could not be resolved. + </summary> + <summary> + Represents that a dependency could not be resolved. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with no extra information. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the given message. + </summary> + <param name="message">Some random message.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.String,System.Exception)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the given + message and inner exception. + </summary> + <param name="message">Some random message</param> + <param name="innerException">Inner exception.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the build key of the object begin built. + </summary> + <param name="buildKey">The build key of the object begin built.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with serialized data. + </summary> + <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param> + <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination. </param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"> + <summary> + The exception thrown when injection is attempted on a method + that is an open generic or has out or ref params. + </summary> + <summary> + The exception thrown when injection is attempted on a method + that is an open generic or has out or ref params. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with no + message. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor(System.String)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with the given message + </summary> + <param name="message">Message to return.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor(System.String,System.Exception)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with the given message + and inner exception. + </summary> + <param name="message">Message to return.</param> + <param name="innerException">Inner exception</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <summary> + Used for serialization. + </summary> + <param name="info">Serialization info.</param> + <param name="context">Serialization context.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions"> + <summary> + Extension methods to provide convenience overloads over the + <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> interface. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.NewBuildUp``1(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Start a recursive build up operation to retrieve the default + value for the given <typeparamref name="TResult"/> type. + </summary> + <typeparam name="TResult">Type of object to build.</typeparam> + <param name="context">Parent context.</param> + <returns>Resulting object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.NewBuildUp``1(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.String)"> + <summary> + Start a recursive build up operation to retrieve the named + implementation for the given <typeparamref name="TResult"/> type. + </summary> + <typeparam name="TResult">Type to resolve.</typeparam> + <param name="context">Parent context.</param> + <param name="name">Name to resolve with.</param> + <returns>The resulting object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.AddResolverOverrides(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Add a set of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>s to the context, specified as a + variable argument list. + </summary> + <param name="context">Context to add overrides to.</param> + <param name="overrides">The overrides.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IRecoveryStack"> + <summary> + Data structure that stores the set of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> + objects and executes them when requested. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.Add(Microsoft.Practices.ObjectBuilder2.IRequiresRecovery)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> object to this + list. + </summary> + <param name="recovery">Object to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.ExecuteRecovery"> + <summary> + Execute the <see cref="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"/> method + of everything in the recovery list. Recoveries will execute + in the opposite order of add - it's a stack. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.Count"> + <summary> + Return the number of recovery objects currently in the stack. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"> + <summary> + Represents a lifetime container. + </summary> + <remarks> + A lifetime container tracks the lifetime of an object, and implements + IDisposable. When the container is disposed, any objects in the + container which implement IDisposable are also disposed. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Add(System.Object)"> + <summary> + Adds an object to the lifetime container. + </summary> + <param name="item">The item to be added to the lifetime container.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Contains(System.Object)"> + <summary> + Determine if a given object is in the lifetime container. + </summary> + <param name="item"> + The item to locate in the lifetime container. + </param> + <returns> + Returns true if the object is contained in the lifetime + container; returns false otherwise. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Remove(System.Object)"> + <summary> + Removes an item from the lifetime container. The item is + not disposed. + </summary> + <param name="item">The item to be removed.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Count"> + <summary> + Gets the number of references in the lifetime container + </summary> + <value> + The number of references in the lifetime container + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LifetimeContainer"> + <summary> + Represents a lifetime container. + </summary> + <remarks> + A lifetime container tracks the lifetime of an object, and implements + IDisposable. When the container is disposed, any objects in the + container which implement IDisposable are also disposed. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Add(System.Object)"> + <summary> + Adds an object to the lifetime container. + </summary> + <param name="item">The item to be added to the lifetime container.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Contains(System.Object)"> + <summary> + Determine if a given object is in the lifetime container. + </summary> + <param name="item"> + The item to locate in the lifetime container. + </param> + <returns> + Returns true if the object is contained in the lifetime + container; returns false otherwise. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Dispose"> + <summary> + Releases the resources used by the <see cref="T:Microsoft.Practices.ObjectBuilder2.LifetimeContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Dispose(System.Boolean)"> + <summary> + Releases the managed resources used by the DbDataReader and optionally releases the unmanaged resources. + </summary> + <param name="disposing"> + true to release managed and unmanaged resources; false to release only unmanaged resources. + </param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the lifetime container. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the life time container. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through the lifetime container. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the life time container. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Remove(System.Object)"> + <summary> + Removes an item from the lifetime container. The item is + not disposed. + </summary> + <param name="item">The item to be removed.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Count"> + <summary> + Gets the number of references in the lifetime container + </summary> + <value> + The number of references in the lifetime container + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"> + <summary> + A custom collection over <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Clear(System.Type,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <param name="policyInterface">The type of policy to remove.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.ClearAll"> + <summary> + Removes all policies from the list. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.ClearDefault(System.Type)"> + <summary> + Removes a default policy. + </summary> + <param name="policyInterface">The type the policy was registered as.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Get(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.GetNoDefault(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies to.</param> + <param name="localOnly">True if the search should be in the local policy list only; otherwise false to search up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Set(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <param name="policyInterface">The <see cref="T:System.Type"/> of the policy.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.SetDefault(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <param name="policyInterface">The interface to register the policy under.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PolicyList"> + <summary> + A custom collection wrapper over <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.#ctor"> + <summary> + Initialize a new instance of a <see cref="T:Microsoft.Practices.ObjectBuilder2.PolicyList"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.#ctor(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Initialize a new instance of a <see cref="T:Microsoft.Practices.ObjectBuilder2.PolicyList"/> class with another policy list. + </summary> + <param name="innerPolicyList">An inner policy list to search.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Clear(System.Type,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <param name="policyInterface">The type of policy to remove.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.ClearAll"> + <summary> + Removes all policies from the list. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.ClearDefault(System.Type)"> + <summary> + Removes a default policy. + </summary> + <param name="policyInterface">The type the policy was registered as.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Get(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.GetNoDefault(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies to.</param> + <param name="localOnly">True if the search should be in the local policy list only; otherwise false to search up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Set(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <param name="policyInterface">The <see cref="T:System.Type"/> of the policy.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.SetDefault(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <param name="policyInterface">The interface to register the policy under.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.PolicyList.Count"> + <summary> + Gets the number of items in the locator. + </summary> + <value> + The number of items in the locator. + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.RecoveryStack"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRecoveryStack"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.RecoveryStack.Add(Microsoft.Practices.ObjectBuilder2.IRequiresRecovery)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> object to this + list. + </summary> + <param name="recovery">Object to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.RecoveryStack.ExecuteRecovery"> + <summary> + Execute the <see cref="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"/> method + of everything in the recovery list. Recoveries will execute + in the opposite order of add - it's a stack. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.RecoveryStack.Count"> + <summary> + Return the number of recovery objects currently in the stack. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"> + <summary> + Implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/> which will notify an object about + the completion of a BuildUp operation, or start of a TearDown operation. + </summary> + <remarks> + This strategy checks the object that is passing through the builder chain to see if it + implements IBuilderAware and if it does, it will call <see cref="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnBuiltUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"/> + and <see cref="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnTearingDown"/>. This strategy is meant to be used from the + <see cref="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PostInitialization"/> stage. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderAware"> + <summary> + Implemented on a class when it wants to receive notifications + about the build process. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnBuiltUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Called by the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"/> when the object is being built up. + </summary> + <param name="buildKey">The key of the object that was just built up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnTearingDown"> + <summary> + Called by the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"/> when the object is being torn down. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderStage"> + <summary> + Enumeration to represent the object builder stages. + </summary> + <remarks> + The order of the values in the enumeration is the order in which the stages are run. + </remarks> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PreCreation"> + <summary> + Strategies in this stage run before creation. Typical work done in this stage might + include strategies that use reflection to set policies into the context that other + strategies would later use. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.Creation"> + <summary> + Strategies in this stage create objects. Typically you will only have a single policy-driven + creation strategy in this stage. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.Initialization"> + <summary> + Strategies in this stage work on created objects. Typical work done in this stage might + include setter injection and method calls. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PostInitialization"> + <summary> + Strategies in this stage work on objects that are already initialized. Typical work done in + this stage might include looking to see if the object implements some notification interface + to discover when its initialization stage has been completed. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy"> + <summary> + Represents a builder policy for mapping build keys. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"> + <summary> + Represents a builder policy for mapping build keys. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping. This parameter can be null + (called when getting container registrations).</param> + <returns>The new build key.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy"/> with the new build key. + </summary> + <param name="newBuildKey">The new build key.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping, unused in this implementation.</param> + <returns>The new build key.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingStrategy"> + <summary> + Represents a strategy for mapping build keys in the build up operation. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. Looks for the <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"/> + and if found maps the build key for the current operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"/> that can map + generic types. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy"/> instance + that will map generic types. + </summary> + <param name="destinationKey">Build key to map to. This must be or contain an open generic type.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping.</param> + <returns>The new build key.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildPlanStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that will look for a build plan + in the current context. If it exists, it invokes it, otherwise + it creates one and stores it for later, and invokes it. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildPlanStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that chooses + constructors based on these criteria: first, pick a constructor marked with the + <typeparamref name="TInjectionConstructorMarkerAttribute"/> attribute. If there + isn't one, then choose the constructor with the longest parameter list. If that is ambiguous, + then throw. + </summary> + <exception cref="T:System.InvalidOperationException">Thrown when the constructor to choose is ambiguous.</exception> + <typeparam name="TInjectionConstructorMarkerAttribute">Attribute used to mark the constructor to call.</typeparam> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that, when implemented, + will determine which constructor to call from the build plan. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.ConstructorLengthComparer.Compare(System.Reflection.ConstructorInfo,System.Reflection.ConstructorInfo)"> + <summary> + Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + </summary> + + <returns> + Value Condition Less than zerox is less than y.Zerox equals y.Greater than zerox is greater than y. + </returns> + + <param name="y">The second object to compare.</param> + <param name="x">The first object to compare.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicy`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedConstructor"> + <summary> + Objects of this type are the return value from <see cref="M:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + It encapsulates the desired <see cref="T:System.Reflection.ConstructorInfo"/> with the string keys + needed to look up the <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for each + parameter. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1"> + <summary> + Base class for return values from selector policies that + return a memberinfo of some sort plus a list of parameter + keys to look up the parameter resolvers. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters"> + <summary> + Base class for return of selector policies that need + to keep track of a set of parameter keys. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters.AddParameterKey(System.String)"> + <summary> + Add a new parameter key to this object. Keys are assumed + to be in the order of the parameters to the constructor. + </summary> + <param name="newKey">Key for the next parameter to look up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters.GetParameterKeys"> + <summary> + The set of keys for the constructor parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1.#ctor(`0)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1"/>, storing + the given member info. + </summary> + <param name="memberInfo">Member info to store.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1.MemberInfo"> + <summary> + The member info stored. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedConstructor.#ctor(System.Reflection.ConstructorInfo)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedConstructor"/> instance which + contains the given constructor. + </summary> + <param name="constructor">The constructor to wrap.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedConstructor.Constructor"> + <summary> + The constructor this object wraps. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"> + <summary> + This class records the information about which constructor argument is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.#ctor(System.Type,System.String,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"/> class. + </summary> + <param name="typeBeingConstructed">The type that is being constructed.</param> + <param name="constructorSignature">A string representing the constructor being called.</param> + <param name="parameterName">Parameter being resolved.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ToString"> + <summary> + Generate the string describing what parameter was being resolved. + </summary> + <returns>The description string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ConstructorSignature"> + <summary> + String describing the constructor being set up. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ParameterName"> + <summary> + Parameter that's being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that emits IL to call constructors + as part of creating a build plan. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <remarks>Existing object is an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext"/>.</remarks> + <param name="context">The context for the operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetPerBuildSingleton(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to set up a PerResolveLifetimeManager lifetime manager + if the current object is such. + </summary> + <param name="context">Current build context.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.CreateSignatureString(System.Reflection.ConstructorInfo)"> + <summary> + Build up the string that will represent the constructor signature + in any exception message. + </summary> + <param name="constructor"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetCurrentOperationToResolvingParameter(System.String,System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetCurrentOperationToInvokingConstructor(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForAttemptingToConstructInterface(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to throw an exception if + no existing object is present, but the user is attempting to build + an interface (usually due to the lack of a type mapping). + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForNullExistingObject(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to throw an exception if + a dependency cannot be resolved. + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForNullExistingObjectWithInvalidConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.String)"> + <summary> + A helper method used by the generated IL to throw an exception if + a dependency cannot be resolved because of an invalid constructor. + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + <param name="signature">The signature of the invalid constructor.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation"> + <summary> + A class that records that a constructor is about to be call, and is + responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.ToString"> + <summary> + Generate the description string. + </summary> + <returns>The string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.ConstructorSignature"> + <summary> + Constructor we're trying to call. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext"> + <summary> + + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.#ctor(System.Type)"> + <summary> + + </summary> + <param name="typeToBuild"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.AddToBuildPlan(System.Linq.Expressions.Expression)"> + <summary> + + </summary> + <param name="expression"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.CreateParameterExpression(System.String,System.Type,System.Linq.Expressions.Expression)"> + <summary> + + </summary> + <param name="parameterKey"></param> + <param name="parameterType"></param> + <param name="setOperationExpression"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type,System.String)"> + <summary> + Helper method used by generated IL to look up a dependency resolver based on the given key. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of the dependency being resolved.</param> + <param name="resolverKey">Key the resolver was stored under.</param> + <returns>The found dependency resolver.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.TypeToBuild"> + <summary> + The type that is to be built with the dynamic build plan. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.ContextParameter"> + <summary> + The context parameter represeting the <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> used when the build plan is executed. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanMethod"> + <summary> + + </summary> + <param name="context"></param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan"> + <summary> + + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan.#ctor(Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanMethod)"> + <summary> + + </summary> + <param name="buildMethod"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + + </summary> + <param name="context"></param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"/> implementation + that constructs a build plan via dynamic IL emission. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy"/> that + uses the given strategy chain to construct the build plan. + </summary> + <param name="strategies">The strategy chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Construct a build plan. + </summary> + <param name="context">The current build context.</param> + <param name="buildKey">The current build key.</param> + <returns>The created build plan.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation"> + <summary> + A class that records that a constructor is about to be call, and is + responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.ToString"> + <summary> + Generate the description string. + </summary> + <returns>The string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.MethodSignature"> + <summary> + Method we're trying to call. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation"> + <summary> + This class records the information about which constructor argument is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.#ctor(System.Type,System.String,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"/> class. + </summary> + <param name="typeBeingConstructed">The type that is being constructed.</param> + <param name="methodSignature">A string representing the method being called.</param> + <param name="parameterName">Parameter being resolved.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.ToString"> + <summary> + Generate the string describing what parameter was being resolved. + </summary> + <returns>The description string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.MethodSignature"> + <summary> + String describing the method being set up. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.ParameterName"> + <summary> + Parameter that's being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that generates IL to call + chosen methods (as specified by the current <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/>) + as part of object build up. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.SetCurrentOperationToResolvingParameter(System.String,System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.SetCurrentOperationToInvokingMethod(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertyOperation"> + <summary> + A base class that holds the information shared by all operations + performed by the container while setting properties. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:System.Object"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"> + <summary> + Generate the description of this operation. + </summary> + <returns>The string.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.PropertyOperation.PropertyName"> + <summary> + The property value currently being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation"> + <summary> + This class records the information about which property value is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:System.Object"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that generates IL to resolve properties + on an object being built. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.SetCurrentOperationToResolvingPropertyValue(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.SetCurrentOperationToSettingProperty(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation"> + <summary> + This class records the information about which property value is currently + being set, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation"/> class. + </summary> + <param name="typeBeingConstructed">Type property is on.</param> + <param name="propertyName">Name of property being set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FactoryDelegateBuildPlanPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that will examine the given + types and return a sequence of <see cref="T:System.Reflection.MethodInfo"/> objects + that should be called as part of building the object. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> that selects + methods by looking for the given <typeparamref name="TMarkerAttribute"/> + attribute on those methods. + </summary> + <typeparam name="TMarkerAttribute">Type of attribute used to mark methods + to inject.</typeparam> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + <typeparam name="TMarkerAttribute">Attribute that marks methods that should + be called.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicy`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMethod"> + <summary> + Objects of this type are the return value from <see cref="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + It encapsulates the desired <see cref="T:System.Reflection.MethodInfo"/> with the string keys + needed to look up the <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for each + parameter. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMethod.#ctor(System.Reflection.MethodInfo)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedMethod"/> instance which + contains the given method. + </summary> + <param name="method">The method</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedMethod.Method"> + <summary> + The constructor this object wraps. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that returns a sequence + of properties that should be injected for the given type. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertySelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> that looks + for properties marked with the <typeparamref name="TResolutionAttribute"/> + attribute that are also settable and not indexers. + </summary> + <typeparam name="TResolutionAttribute"></typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorPolicy`1.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedProperty"> + <summary> + Objects of this type are returned from + <see cref="M:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + This class combines the <see cref="T:System.Reflection.PropertyInfo"/> about + the property with the string key used to look up the resolver + for this property's value. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedProperty.#ctor(System.Reflection.PropertyInfo,System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedProperty"/> + with the given <see cref="T:System.Reflection.PropertyInfo"/> and key. + </summary> + <param name="property">The property.</param> + <param name="key">Key to use to look up the resolver.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedProperty.Property"> + <summary> + PropertyInfo for this property. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedProperty.Key"> + <summary> + Key to look up this property's resolver. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy"> + <summary> + Implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"/>. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"> + <summary> + A builder policy that lets you keep track of the current + resolvers and will remove them from the given policy set. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy.AddResolverKey(System.Object)"> + <summary> + Add a new resolver to track by key. + </summary> + <param name="key">Key that was used to add the resolver to the policy set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Remove the currently tracked resolvers from the given policy list. + </summary> + <param name="policies">Policy list to remove the resolvers from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.AddResolverKey(System.Object)"> + <summary> + Add a new resolver to track by key. + </summary> + <param name="key">Key that was used to add the resolver to the policy set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Remove the currently tracked resolvers from the given policy list. + </summary> + <param name="policies">Policy list to remove the resolvers from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.GetTracker(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Get an instance that implements <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"/>, + either the current one in the policy set or creating a new one if it doesn't + exist. + </summary> + <param name="policies">Policy list to look up from.</param> + <param name="buildKey">Build key to track.</param> + <returns>The resolver tracker.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.TrackKey(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Object)"> + <summary> + Add a key to be tracked to the current tracker. + </summary> + <param name="policies">Policy list containing the resolvers and trackers.</param> + <param name="buildKey">Build key for the resolvers being tracked.</param> + <param name="resolverKey">Key for the resolver.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Remove the resolvers for the given build key. + </summary> + <param name="policies">Policy list containing the build key.</param> + <param name="buildKey">Build key.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + calls back into the build chain to build up the dependency, passing + a type given at compile time as its build key. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy.#ctor(System.Type)"> + <summary> + Create a new instance storing the given type. + </summary> + <param name="typeToBuild">Type to resolve.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain"> + <summary> + This interface defines a standard method to convert any + <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> regardless + of the stage enum into a regular, flat strategy chain. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain.MakeStrategyChain"> + <summary> + Convert this <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> into + a flat <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>. + </summary> + <returns>The flattened <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"> + <summary> + Represents a chain of responsibility for builder strategies. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.Reverse"> + <summary> + Reverse the order of the strategy chain. + </summary> + <returns>The reversed strategy chain.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.ExecuteBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the Buildup methods on the strategies. + </summary> + <param name="context">Context for the build process.</param> + <returns>The build up object</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.ExecuteTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the TearDown methods on the strategies. + </summary> + <param name="context">Context for the teardown process.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy"> + <summary> + A builder policy used to create lifetime policy instances. + Used by the LifetimeStrategy when instantiating open + generic types. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy.CreateLifetimePolicy"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/>. + </summary> + <returns>The new instance.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy.LifetimeType"> + <summary> + The type of Lifetime manager that will be created by this factory. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/> implementation that uses + a <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/> to figure out if an object + has already been created and to update or remove that + object from some backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"> + <summary> + Represents a chain of responsibility for builder strategies partitioned by stages. + </summary> + <typeparam name="TStageEnum">The stage enumeration to partition the strategies.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.#ctor"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.#ctor(Microsoft.Practices.ObjectBuilder2.StagedStrategyChain{`0})"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> class with an inner strategy chain to use when building. + </summary> + <param name="innerChain">The inner strategy chain to use first when finding strategies in the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.Add(Microsoft.Practices.ObjectBuilder2.IBuilderStrategy,`0)"> + <summary> + Adds a strategy to the chain at a particular stage. + </summary> + <param name="strategy">The strategy to add to the chain.</param> + <param name="stage">The stage to add the strategy.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.AddNew``1(`0)"> + <summary> + Add a new strategy for the <paramref name="stage"/>. + </summary> + <typeparam name="TStrategy">The <see cref="T:System.Type"/> of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/></typeparam> + <param name="stage">The stage to add the strategy.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.Clear"> + <summary> + Clear the current strategy chain list. + </summary> + <remarks> + This will not clear the inner strategy chain if this instane was created with one. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.MakeStrategyChain"> + <summary> + Makes a strategy chain based on this instance. + </summary> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/>.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"> + <summary> + Represents a chain of responsibility for builder strategies. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.#ctor"> + <summary> + Initialzie a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.#ctor(System.Collections.IEnumerable)"> + <summary> + Initialzie a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/> class with a colleciton of strategies. + </summary> + <param name="strategies">A collection of strategies to initialize the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.Add(Microsoft.Practices.ObjectBuilder2.IBuilderStrategy)"> + <summary> + Adds a strategy to the chain. + </summary> + <param name="strategy">The strategy to add to the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.AddRange(System.Collections.IEnumerable)"> + <summary> + Adds strategies to the chain. + </summary> + <param name="strategyEnumerable">The strategies to add to the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.Reverse"> + <summary> + Reverse the order of the strategy chain. + </summary> + <returns>The reversed strategy chain.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context to build up. + </summary> + <param name="context">Context for the build processes.</param> + <returns>The build up object</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the TearDown methods on the strategies. + </summary> + <param name="context">Context for the teardown process.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.System#Collections#Generic#IEnumerable{Microsoft#Practices#ObjectBuilder2#IBuilderStrategy}#GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + + <returns> + An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"> + <summary> + Build key used to combine a type object with a string name. Used by + ObjectBuilder to indicate exactly what is being built. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.#ctor(System.Type,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance with the given + type and name. + </summary> + <param name="type"><see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> to build.</param> + <param name="name">Key to use to look up type mappings and singletons.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance for the default + buildup of the given type. + </summary> + <param name="type"><see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> to build.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Make``1"> + <summary> + This helper method creates a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance. It is + initialized for the default key for the given type. + </summary> + <typeparam name="T">Type to build.</typeparam> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Make``1(System.String)"> + <summary> + This helper method creates a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance for + the given type and key. + </summary> + <typeparam name="T">Type to build</typeparam> + <param name="name">Key to use to look up type mappings and singletons.</param> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance initialized with the given type and name.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Equals(System.Object)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type. Also, comparing + against a different type will also return false.</remarks> + <param name="obj">Object to compare to.</param> + <returns>True if the two keys are equal, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.GetHashCode"> + <summary> + Calculate a hash code for this instance. + </summary> + <returns>A hash code.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.op_Equality(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances for equality. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type.</remarks> + <param name="left">First of the two keys to compare.</param> + <param name="right">Second of the two keys to compare.</param> + <returns>True if the values of the keys are the same, else false.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.op_Inequality(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances for inequality. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type. If either field differs + the keys are not equal.</remarks> + <param name="left">First of the two keys to compare.</param> + <param name="right">Second of the two keys to compare.</param> + <returns>false if the values of the keys are the same, else true.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.ToString"> + <summary> + Formats the build key as a string (primarily for debugging). + </summary> + <returns>A readable string representation of the build key.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"> + <summary> + Return the <see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> stored in this build key. + </summary> + <value>The type to build.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Name"> + <summary> + Returns the name stored in this build key. + </summary> + <remarks>The name to use when building.</remarks> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> so that + you can new up a key using generic syntax. + </summary> + <typeparam name="T">Type for the key.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"/> that + specifies the given type. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"/> that + specifies the given type and name. + </summary> + <param name="name">Name for the key.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.Sequence"> + <summary> + A series of helper methods to deal with sequences - + objects that implement <see cref="T:System.Collections.Generic.IEnumerable`1"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.Sequence.Collect``1(``0[])"> + <summary> + A function that turns an arbitrary parameter list into an + <see cref="T:System.Collections.Generic.IEnumerable`1"/>. + </summary> + <typeparam name="T">Type of arguments.</typeparam> + <param name="arguments">The items to put into the collection.</param> + <returns>An array that contains the values of the <paramref name="arguments"/>.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.Sequence.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})"> + <summary> + Given two sequences, return a new sequence containing the corresponding values + from each one. + </summary> + <typeparam name="TFirstSequenceElement">Type of first sequence.</typeparam> + <typeparam name="TSecondSequenceElement">Type of second sequence.</typeparam> + <param name="sequence1">First sequence of items.</param> + <param name="sequence2">Second sequence of items.</param> + <returns>New sequence of pairs. This sequence ends when the shorter of sequence1 and sequence2 does.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolutionFailedException"> + <summary> + The exception thrown by the Unity container when + an attempt to resolve a dependency fails. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolutionFailedException.#ctor(System.Type,System.String,System.Exception,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolutionFailedException"/> that records + the exception for the given type and name. + </summary> + <param name="typeRequested">Type requested from the container.</param> + <param name="nameRequested">Name requested from the container.</param> + <param name="innerException">The actual exception that caused the failure of the build.</param> + <param name="context">The build context representing the failed operation.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ResolutionFailedException.TypeRequested"> + <summary> + The type that was being requested from the container at the time of failure. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ResolutionFailedException.NameRequested"> + <summary> + The name that was being requested from the container at the time of failure. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> that lets you register a + delegate with the container to create an object, rather than calling + the object's constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerExtension"> + <summary> + Base class for all <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> extension objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.InitializeExtension(Microsoft.Practices.Unity.ExtensionContext)"> + <summary> + The container calls this method when the extension is added. + </summary> + <param name="context">A <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> instance that gives the + extension access to the internals of the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.Initialize"> + <summary> + Initial the container with this extension's functionality. + </summary> + <remarks> + When overridden in a derived class, this method will modify the given + <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> by adding strategies, policies, etc. to + install it's functions into the container.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.Remove"> + <summary> + Removes the extension's functions from the container. + </summary> + <remarks> + <para> + This method is called when extensions are being removed from the container. It can be + used to do things like disconnect event handlers or clean up member state. You do not + need to remove strategies or policies here; the container will do that automatically. + </para> + <para> + The default implementation of this method does nothing.</para> + </remarks> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainerExtension.Container"> + <summary> + The container this extension has been added to. + </summary> + <value>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> that this extension has been added to.</value> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainerExtension.Context"> + <summary> + The <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> object used to manipulate + the inner state of the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.Initialize"> + <summary> + Initialize this extension. This particular extension requires no + initialization work. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.RegisterFactory``1(System.String,System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/> and <paramref name="name"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="name">The name that will be used when requesting to resolve this type.</param> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.RegisterFactory``1(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.TypeBasedOverride"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that + acts as a decorator over another <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>. + This checks to see if the current type being built is the + right one before checking the inner <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride.#ctor(System.Type,Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride"/> + </summary> + <param name="targetType">Type to check for.</param> + <param name="innerOverride">Inner override to check after type matches.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.TypeBasedOverride`1"> + <summary> + A convenience version of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride"/> that lets you + specify the type to construct via generics syntax. + </summary> + <typeparam name="T">Type to check for.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride`1.#ctor(Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride`1"/>. + </summary> + <param name="innerOverride">Inner override to check after type matches.</param> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerExtensions"> + <summary> + Extension class that adds a set of convenience overloads to the + <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> interface. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type with specific members to be injected. + </summary> + <typeparam name="T">Type this registration is for.</typeparam> + <param name="container">Container to configure.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + <para> + This method is used to tell the container that when asked for type <typeparamref name="TFrom"/>, + actually return an instance of type <typeparamref name="TTo"/>. This is very useful for + getting instances of interfaces. + </para> + <para> + This overload registers a default mapping and transient lifetime. + </para> + </remarks> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + This method is used to tell the container that when asked for type <typeparamref name="TFrom"/>, + actually return an instance of type <typeparamref name="TTo"/>. This is very useful for + getting instances of interfaces. + </remarks> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name of this mapping.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to apply the <paramref name="lifetimeManager"/> to.</typeparam> + <param name="container">Container to configure.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to configure injection on.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name that will be used to request the type.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to apply the <paramref name="lifetimeManager"/> to.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name that will be used to request the type.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type with specific members to be injected. + </summary> + <param name="container">Container to configure.</param> + <param name="t">Type this registration is for.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + <para> + This method is used to tell the container that when asked for type <paramref name="from"/>, + actually return an instance of type <paramref name="to"/>. This is very useful for + getting instances of interfaces. + </para> + <para> + This overload registers a default mapping. + </para> + </remarks> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + This method is used to tell the container that when asked for type <paramref name="from"/>, + actually return an instance of type <paramref name="to"/>. This is very useful for + getting instances of interfaces. + </remarks> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to apply the <paramref name="lifetimeManager"/> to.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to configure in the container.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to apply the <paramref name="lifetimeManager"/> to.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,``0)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration and has the container take over the lifetime of the instance.</para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="container">Container to configure.</param> + <param name="instance">Object to returned.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,``0,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration (name = null). + </para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="container">Container to configure.</param> + <param name="instance">Object to returned.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,System.String,``0)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload automatically has the container take ownership of the <paramref name="instance"/>.</para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="instance">Object to returned.</param> + <param name="container">Container to configure.</param> + <param name="name">Name for registration.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,System.String,``0,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="instance">Object to returned.</param> + <param name="container">Container to configure.</param> + <param name="name">Name for registration.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration and has the container take over the lifetime of the instance.</para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration (name = null). + </para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,System.Object)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload automatically has the container take ownership of the <paramref name="instance"/>.</para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the default requested type from the container. + </summary> + <typeparam name="T"><see cref="T:System.Type"/> of object to get from the container.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the requested type with the given name from the container. + </summary> + <typeparam name="T"><see cref="T:System.Type"/> of object to get from the container.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the default requested type from the container. + </summary> + <param name="container">Container to resolve from.</param> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.ResolveAll``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <typeparam name="T">The type requested.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <typeparamref name="T"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp``1(Microsoft.Practices.Unity.IUnityContainer,``0,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para> + <para> + This overload uses the default registrations. + </para> + </remarks> + <typeparam name="T"><see cref="T:System.Type"/> of object to perform injection on.</typeparam> + <param name="container">Container to resolve through.</param> + <param name="existing">Instance to build up.</param> + <param name="resolverOverrides">Any overrides for the buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <typeparamref name="T"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp``1(Microsoft.Practices.Unity.IUnityContainer,``0,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <typeparam name="T"><see cref="T:System.Type"/> of object to perform injection on.</typeparam> + <param name="container">Conatiner to resolve through.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the Buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <typeparamref name="T"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para> + <para> + This overload uses the default registrations. + </para> + </remarks> + <param name="container">Container to resolve through.</param> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="resolverOverrides">Any overrides for the Buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.AddNewExtension``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Creates a new extension object and adds it to the container. + </summary> + <typeparam name="TExtension">Type of <see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add. The extension type + will be resolved from within the supplied <paramref name="container"/>.</typeparam> + <param name="container">Container to add the extension to.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Configure``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Resolve access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <typeparam name="TConfigurator">The configuration interface required.</typeparam> + <param name="container">Container to configure.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Check if a particular type has been registered with the container with + the default name. + </summary> + <param name="container">Container to inspect.</param> + <param name="typeToCheck">Type to check registration for.</param> + <returns>True if this type has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String)"> + <summary> + Check if a particular type/name pair has been registered with the container. + </summary> + <param name="container">Container to inspect.</param> + <param name="typeToCheck">Type to check registration for.</param> + <param name="nameToCheck">Name to check registration for.</param> + <returns>True if this type/name pair has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Check if a particular type has been registered with the container with the default name. + </summary> + <typeparam name="T">Type to check registration for.</typeparam> + <param name="container">Container to inspect.</param> + <returns>True if this type has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered``1(Microsoft.Practices.Unity.IUnityContainer,System.String)"> + <summary> + Check if a particular type/name pair has been registered with the container. + </summary> + <typeparam name="T">Type to check registration for.</typeparam> + <param name="container">Container to inspect.</param> + <param name="nameToCheck">Name to check registration for.</param> + <returns>True if this type/name pair has been registered, false if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ExtensionContext"> + <summary> + The <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> class provides the means for extension objects + to manipulate the internal state of the <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ExtensionContext.RegisterNamedType(System.Type,System.String)"> + <summary> + Store a type/name pair for later resolution. + </summary> + <remarks> + <para> + When users register type mappings (or other things) with a named key, this method + allows you to register that name with the container so that when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"/> + method is called, that name is included in the list that is returned. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> to register.</param> + <param name="name">Name assocated with that type.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Container"> + <summary> + The container that this context is associated with. + </summary> + <value>The <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> object.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Strategies"> + <summary> + The strategies this container uses. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> that the container uses to build objects.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.BuildPlanStrategies"> + <summary> + The strategies this container uses to construct build plans. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> that this container uses when creating + build plans.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Policies"> + <summary> + The policies this container uses. + </summary> + <remarks>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> the that container uses to build objects.</remarks> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Lifetime"> + <summary> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> that this container uses. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> is used to manage <see cref="T:System.IDisposable"/> objects that the container is managing.</value> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.Registering"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.RegisteringInstance"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.ChildContainerCreated"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.CreateChildContainer"/> method is called, providing + the newly created child container to extensions to act on as they see fit. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.NamedEventArgs"> + <summary> + An EventArgs class that holds a string Name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.NamedEventArgs.#ctor"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.NamedEventArgs"/> with a null name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.NamedEventArgs.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.NamedEventArgs"/> with the given name. + </summary> + <param name="name">Name to store.</param> + </member> + <member name="P:Microsoft.Practices.Unity.NamedEventArgs.Name"> + <summary> + The name. + </summary> + <value>Name used for this event arg object.</value> + </member> + <member name="T:Microsoft.Practices.Unity.RegisterEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.Registering"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterEventArgs.#ctor(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.RegisterEventArgs"/>. + </summary> + <param name="typeFrom">Type to map from.</param> + <param name="typeTo">Type to map to.</param> + <param name="name">Name for the registration.</param> + <param name="lifetimeManager"><see cref="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"/> to manage instances.</param> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.TypeFrom"> + <summary> + Type to map from. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.TypeTo"> + <summary> + Type to map to. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"> + <summary> + <see cref="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"/> to manage instances. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.RegisteringInstance"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterInstanceEventArgs.#ctor"> + <summary> + Create a default <see cref="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"/> instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterInstanceEventArgs.#ctor(System.Type,System.Object,System.String,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Create a <see cref="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"/> instance initialized with the given arguments. + </summary> + <param name="registeredType">Type of instance being registered.</param> + <param name="instance">The instance object itself.</param> + <param name="name">Name to register under, null if default registration.</param> + <param name="lifetimeManager"><see cref="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.LifetimeManager"/> object that handles how + the instance will be owned.</param> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.RegisteredType"> + <summary> + Type of instance being registered. + </summary> + <value> + Type of instance being registered. + </value> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.Instance"> + <summary> + Instance object being registered. + </summary> + <value>Instance object being registered</value> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.LifetimeManager"> + <summary> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls ownership of + this instance. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.GenericParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an instance of a generic type parameter should be resolved. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.GenericResolvedArrayParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an array containing the registered instances of a generic type parameter + should be resolved. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.#ctor(System.String,System.Object[])"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericResolvedArrayParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + <remarks>A type is considered compatible if it is an array type of rank one + and its element type is a generic type parameter with a name matching this generic + parameter name configured for the receiver.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.GenericResolvedArrayParameter.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectedMembers"> + <summary> + A Unity container extension that allows you to configure + which constructors, properties, and methods get injected + via an API rather than through attributes. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.Initialize"> + <summary> + Initial the container with this extension's functionality. + </summary> + <remarks> + When overridden in a derived class, this method will modify the given + <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> by adding strategies, policies, etc. to + install it's functions into the container.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor``1(Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type. + </summary> + <typeparam name="TTypeToInject">Type the injection is being configured for.</typeparam> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor``1(System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <typeparam name="TTypeToInject">Type the injection is being configured for.</typeparam> + <param name="name">Name of registration</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type. + </summary> + <param name="typeToInject">Type to configure.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <param name="typeToInject">Type to configure.</param> + <param name="name">Name of registration.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <param name="serviceType">Type of interface/base class being registered (may be null).</param> + <param name="implementationType">Type of actual implementation class being registered.</param> + <param name="name">Name of registration.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionConstructor"> + <summary> + A class that holds the collection of information + for a constructor, so that the container can + be configured to call this constructor. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionConstructor.#ctor(System.Object[])"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionConstructor"/> that looks + for a constructor with the given set of parameters. + </summary> + <param name="parameterValues">The values for the parameters, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionConstructor.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Interface registered, ignored in this implementation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMethod"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> that configures the + container to call a method as part of buildup. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.#ctor(System.String,System.Object[])"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.InjectionMethod"/> instance which will configure + the container to call the given methods with the given parameters. + </summary> + <param name="methodName">Name of the method to call.</param> + <param name="methodParameters">Parameter values for the method.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface registered, ignored in this implementation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.MethodNameMatches(System.Reflection.MemberInfo,System.String)"> + <summary> + A small function to handle name matching. You can override this + to do things like case insensitive comparisons. + </summary> + <param name="targetMethod">MethodInfo for the method you're checking.</param> + <param name="nameToMatch">Name of the method you're looking for.</param> + <returns>True if a match, false if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameter"> + <summary> + A class that holds on to the given value and provides + the required <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> + when the container is configured. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.#ctor(System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that stores + the given value, using the runtime type of that value as the + type of the parameter. + </summary> + <param name="parameterValue">Value to be injected for this parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.#ctor(System.Type,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that stores + the given value, associated with the given type. + </summary> + <param name="parameterType">Type of the parameter.</param> + <param name="parameterValue">Value of the parameter</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that makes it a + little easier to specify the type of the parameter. + </summary> + <typeparam name="TParameter">Type of parameter.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter`1.#ctor(`0)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.InjectionParameter`1"/>. + </summary> + <param name="parameterValue">Value for the parameter.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionProperty"> + <summary> + This class stores information about which properties to inject, + and will configure the container accordingly. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.#ctor(System.String)"> + <summary> + Configure the container to inject the given property name, + resolving the value via the container. + </summary> + <param name="propertyName">Name of the property to inject.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.#ctor(System.String,System.Object)"> + <summary> + Configure the container to inject the given property name, + using the value supplied. This value is converted to an + <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object using the + rules defined by the <see cref="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameters(System.Object[])"/> + method. + </summary> + <param name="propertyName">Name of property to inject.</param> + <param name="propertyValue">Value for property.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Interface being registered, ignored in this implemenation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayParameter"> + <summary> + A class that stores a type, and generates a + resolver object that resolves all the named instances or the + type registered in a container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.#ctor(System.Type,System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> that + resolves to the given element type and collection of element values. + </summary> + <param name="elementType">The type of elements to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.#ctor(System.Type,System.Type,System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> that + resolves to the given array and element types and collection of element values. + </summary> + <param name="arrayParameterType">The type for the array of elements to resolve.</param> + <param name="elementType">The type of elements to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> for convenience + when creating them by hand. + </summary> + <typeparam name="TElement">Type of the elements for the array of the parameter.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter`1.#ctor(System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter`1"/> that + resolves to the given element generic type with the given element values. + </summary> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="T:Microsoft.Practices.Unity.IUnityContainer"> + <summary> + Interface defining the behavior of the Unity dependency injection container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <param name="lifetime"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the requested type with the given name from the container. + </summary> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="resolverOverrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <param name="t">The type requested.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <paramref name="t"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.BuildUp(System.Type,System.Object,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Teardown(System.Object)"> + <summary> + Run an existing object through the container, and clean it up. + </summary> + <param name="o">The object to tear down.</param> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.AddExtension(Microsoft.Practices.Unity.UnityContainerExtension)"> + <summary> + Add an extension object to the container. + </summary> + <param name="extension"><see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Configure(System.Type)"> + <summary> + Resolve access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <param name="configurationInterface"><see cref="T:System.Type"/> of configuration interface required.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RemoveAllExtensions"> + <summary> + Remove all installed extensions from this container. + </summary> + <remarks> + <para> + This method removes all extensions from the container, including the default ones + that implement the out-of-the-box behavior. After this method, if you want to use + the container again you will need to either readd the default extensions or replace + them with your own. + </para> + <para> + The registered instances and singletons that have already been set up in this container + do not get removed. + </para> + </remarks> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.CreateChildContainer"> + <summary> + Create a child container. + </summary> + <remarks> + A child container shares the parent's configuration, but can be configured with different + settings or lifetime.</remarks> + <returns>The new child container.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainer.Parent"> + <summary> + The parent of this container. + </summary> + <value>The parent container, or null if this container doesn't have one.</value> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainer.Registrations"> + <summary> + Get a sequence of <see cref="T:Microsoft.Practices.Unity.ContainerRegistration"/> that describe the current state + of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that holds a weak reference to + it's managed instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.LifetimeManagerFactory"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy"/> that + creates instances of the type of the given Lifetime Manager + by resolving them through the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManagerFactory.#ctor(Microsoft.Practices.Unity.ExtensionContext,System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.LifetimeManagerFactory"/> that will + return instances of the given type, creating them by + resolving through the container. + </summary> + <param name="containerContext">Container to resolve with.</param> + <param name="lifetimeType">Type of LifetimeManager to create.</param> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManagerFactory.CreateLifetimePolicy"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/>. + </summary> + <returns>The new instance.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.LifetimeManagerFactory.LifetimeType"> + <summary> + The type of Lifetime manager that will be created by this factory. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.PerThreadLifetimeManager"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that holds the instances given to it, + keeping one instance per thread. + </summary> + <remarks> + <para> + This LifetimeManager does not dispose the instances it holds. + </para> + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.PerThreadLifetimeManager.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.Unity.PerThreadLifetimeManager"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PerThreadLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy for the + current thread. + </summary> + <returns>the object desired, or <see langword="null"/> if no such object is currently + stored for the current thread.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.PerThreadLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later when requested + in the current thread. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PerThreadLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + <remarks>Not implemented for this lifetime manager.</remarks> + </member> + <member name="T:Microsoft.Practices.Unity.TransientLifetimeManager"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> implementation that does nothing, + thus ensuring that instances are created new every time. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ArrayResolutionStrategy"> + <summary> + This strategy implements the logic that will call container.ResolveAll + when an array parameter is detected. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ArrayResolutionStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Do the PreBuildUp stage of construction. This is where the actual work is performed. + </summary> + <param name="context">Current build context.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityConstructorSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that is + aware of the build keys used by the Unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityConstructorSelectorPolicy.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <remarks> + This implementation looks for the Unity <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> on the + parameter and uses it to create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"/> + for this parameter.</remarks> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityMethodSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> that is aware + of the build keys used by the Unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityMethodSelectorPolicy.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityPropertySelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> that is aware of + the build keys used by the unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityPropertySelectorPolicy.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> implementation that returns + the value set in the constructor. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy.#ctor(System.Object)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy"/> + which will return the given value when resolved. + </summary> + <param name="dependencyValue">The value to return.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that stores a + type and name, and at resolution time puts them together into a + <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.#ctor(System.Type,System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"/> + with the given type and name. + </summary> + <param name="type">The type.</param> + <param name="name">The name (may be null).</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Resolve the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Type"> + <summary> + The type that this resolver resolves. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Name"> + <summary> + The name that this resolver resolves. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that resolves to + to an array populated with the values that result from resolving other instances + of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy.#ctor(System.Type,Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy[])"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy"/> + with the given type and a collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> + instances to use when populating the result. + </summary> + <param name="elementType">The type.</param> + <param name="elementPolicies">The resolver policies to use when populating an array.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Resolve the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>An array pupulated with the results of resolving the resolver policies.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that selects + the given constructor and creates the appropriate resolvers to call it with + the specified parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy.#ctor(System.Reflection.ConstructorInfo,Microsoft.Practices.Unity.InjectionParameterValue[])"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy"/> that + will return the given constructor, being passed the given injection values + as parameters. + </summary> + <param name="ctor">The constructor to call.</param> + <param name="parameterValues">Set of <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects + that describes how to obtain the values for the constructor parameters.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMemberSelectorHelper"> + <summary> + Helper class for implementing selector policies that need to + set up dependency resolver policies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMemberSelectorHelper.AddParameterResolvers(System.Type,Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue},Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters)"> + <summary> + Add dependency resolvers to the parameter set. + </summary> + <param name="typeToBuild">Type that's currently being built (used to resolve open generics).</param> + <param name="policies">PolicyList to add the resolvers to.</param> + <param name="parameterValues">Objects supplying the dependency resolvers.</param> + <param name="result">Result object to store the keys in.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> implementation that calls the specific + methods with the given parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy.AddMethodAndParameters(System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue})"> + <summary> + Add the given method and parameter collection to the list of methods + that will be returned when the selector's <see cref="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/> + method is called. + </summary> + <param name="method">Method to call.</param> + <param name="parameters">sequence of <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects + that describe how to create the method parameter values.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy"> + <summary> + An implemnetation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> which returns + the set of specific properties that the selector was configured with. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.AddPropertyAndValue(System.Reflection.PropertyInfo,Microsoft.Practices.Unity.InjectionParameterValue)"> + <summary> + Add a property that will be par of the set returned when the + <see cref="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/> is called. + </summary> + <param name="property">The property to set.</param> + <param name="value"><see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object describing + how to create the value to inject.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedParameter"> + <summary> + A class that stores a name and type, and generates a + resolver object that resolves the parameter via the + container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> that + resolves to the given type. + </summary> + <param name="parameterType">Type of this parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> that + resolves the given type and name. + </summary> + <param name="parameterType">Type of this parameter.</param> + <param name="name">Name to use when resolving parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> for convenience + when creating them by hand. + </summary> + <typeparam name="TParameter">Type of the parameter</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter`1.#ctor"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter`1"/> for the given + generic type and the default name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter`1.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter`1"/> for the given + generic type and name. + </summary> + <param name="name">Name to use to resolve this parameter.</param> + </member> + <member name="T:Microsoft.Practices.Unity.UnityServiceLocator"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ServiceLocation.IServiceLocator"/> that wraps a Unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityServiceLocator.#ctor(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.Unity.UnityServiceLocator"/> class for a container. + </summary> + <param name="container">The <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> to wrap with the <see cref="T:Microsoft.Practices.ServiceLocation.IServiceLocator"/> + interface implementation.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityServiceLocator.Dispose"> + <summary> + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + </summary> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.UnityServiceLocator.DoGetInstance(System.Type,System.String)"> + <summary> + When implemented by inheriting classes, this method will do the actual work of resolving + the requested service instance. + </summary> + <param name="serviceType">Type of instance requested.</param><param name="key">Name of registered service you want. May be null.</param> + <returns> + The requested service instance. + </returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityServiceLocator.DoGetAllInstances(System.Type)"> + <summary> + When implemented by inheriting classes, this method will do the actual work of + resolving all the requested service instances. + </summary> + <param name="serviceType">Type of service requested.</param> + <returns> + Sequence of service instance objects. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Guard"> + <summary> + A static helper class that includes various parameter checking routines. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(System.Object,System.String)"> + <summary> + Throws <see cref="T:System.ArgumentNullException"/> if the given argument is null. + </summary> + <exception cref="T:System.ArgumentNullException"> if tested value if null.</exception> + <param name="argumentValue">Argument value to test.</param> + <param name="argumentName">Name of the argument being tested.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNullOrEmpty(System.String,System.String)"> + <summary> + Throws an exception if the tested string argument is null or the empty string. + </summary> + <exception cref="T:System.ArgumentNullException">Thrown if string value is null.</exception> + <exception cref="T:System.ArgumentException">Thrown if the string is empty</exception> + <param name="argumentValue">Argument value to check.</param> + <param name="argumentName">Name of argument being checked.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.TypeIsAssignable(System.Type,System.Type,System.String)"> + <summary> + Verifies that an argument type is assignable from the provided type (meaning + interfaces are implemented, or classes exist in the base class hierarchy). + </summary> + <param name="assignmentTargetType">The argument type that will be assigned to.</param> + <param name="assignmentValueType">The type of the value being assigned.</param> + <param name="argumentName">Argument name.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.InstanceIsAssignable(System.Type,System.Object,System.String)"> + <summary> + Verifies that an argument instance is assignable from the provided type (meaning + interfaces are implemented, or classes exist in the base class hierarchy, or instance can be + assigned through a runtime wrapper, as is the case for COM Objects). + </summary> + <param name="assignmentTargetType">The argument type that will be assigned to.</param> + <param name="assignmentInstance">The instance that will be assigned.</param> + <param name="argumentName">Argument name.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage"> + <summary> + The build stages we use in the Unity container + strategy pipeline. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Setup"> + <summary> + First stage. By default, nothing happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.TypeMapping"> + <summary> + Second stage. Type mapping occurs here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Lifetime"> + <summary> + Third stage. lifetime managers are checked here, + and if they're available the rest of the pipeline is skipped. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.PreCreation"> + <summary> + Fourth stage. Reflection over constructors, properties, etc. is + performed here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Creation"> + <summary> + Fifth stage. Instance creation happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Initialization"> + <summary> + Sixth stage. Property sets and method injection happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.PostInitialization"> + <summary> + Seventh and final stage. By default, nothing happens here. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Properties.Resources"> + <summary> + A strongly-typed resource class, for looking up localized strings, etc. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResourceManager"> + <summary> + Returns the cached ResourceManager instance used by this class. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.Culture"> + <summary> + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.AmbiguousInjectionConstructor"> + <summary> + Looks up a localized string similar to The type {0} has multiple constructors of length {1}. Unable to disambiguate.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ArgumentMustNotBeEmpty"> + <summary> + Looks up a localized string similar to The provided string argument must not be empty.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.BuildFailedException"> + <summary> + Looks up a localized string similar to The current build operation (build key {2}) failed: {3} (Strategy type {0}, index {1}). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotConstructInterface"> + <summary> + Looks up a localized string similar to The current type, {0}, is an interface and cannot be constructed. Are you missing a type mapping?. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotExtractTypeFromBuildKey"> + <summary> + Looks up a localized string similar to Cannot extract type from build key {0}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectGenericMethod"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) is an open generic method. Open generic methods cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectIndexer"> + <summary> + Looks up a localized string similar to The property {0} on type {1} is an indexer. Indexed properties cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithOutParam"> + <summary> + Looks up a localized string similar to The method {1} on type {0} has an out parameter. Injection cannot be performed.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithOutParams"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) has at least one out parameter. Methods with out parameters cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithRefParams"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) has at least one ref parameter.Methods with ref parameters cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectOpenGenericMethod"> + <summary> + Looks up a localized string similar to The method {1} on type {0} is marked for injection, but it is an open generic method. Injection cannot be performed.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectStaticMethod"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) is static. Static methods cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotResolveOpenGenericType"> + <summary> + Looks up a localized string similar to The type {0} is an open generic type. An open generic type cannot be resolved.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ConstructorArgumentResolveOperation"> + <summary> + Looks up a localized string similar to Resolving parameter "{0}" of constructor {1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ConstructorParameterResolutionFailed"> + <summary> + Looks up a localized string similar to The parameter {0} could not be resolved when attempting to call constructor {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.DuplicateTypeMappingException"> + <summary> + Looks up a localized string similar to An attempt to override an existing mapping was detected for type {1} with name "{0}", currently mapped to type {2}, to type {3}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ExceptionNullAssembly"> + <summary> + Looks up a localized string similar to The set of assemblies contains a null element.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ExceptionNullParameterValue"> + <summary> + Looks up a localized string similar to Parameter type inference does not work for null values. Indicate the parameter type explicitly using a properly configured instance of the InjectionParameter or InjectionParameter<T> classes.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.InvokingConstructorOperation"> + <summary> + Looks up a localized string similar to Calling constructor {0}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.InvokingMethodOperation"> + <summary> + Looks up a localized string similar to Calling method {0}.{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.KeyAlreadyPresent"> + <summary> + Looks up a localized string similar to An item with the given key is already present in the dictionary.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.LifetimeManagerInUse"> + <summary> + Looks up a localized string similar to The lifetime manager is already registered. Lifetime managers cannot be reused, please create a new one.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MarkerBuildPlanInvoked"> + <summary> + Looks up a localized string similar to The override marker build plan policy has been invoked. This should never happen, looks like a bug in the container.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MethodArgumentResolveOperation"> + <summary> + Looks up a localized string similar to Resolving parameter "{0}" of method {1}.{2}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MethodParameterResolutionFailed"> + <summary> + Looks up a localized string similar to The value for parameter "{1}" of method {0} could not be resolved. . + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MissingDependency"> + <summary> + Looks up a localized string similar to Could not resolve dependency for build key {0}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MultipleInjectionConstructors"> + <summary> + Looks up a localized string similar to The type {0} has multiple constructors marked with the InjectionConstructor attribute. Unable to disambiguate.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MustHaveOpenGenericType"> + <summary> + Looks up a localized string similar to The supplied type {0} must be an open generic type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MustHaveSameNumberOfGenericArguments"> + <summary> + Looks up a localized string similar to The supplied type {0} does not have the same number of generic arguments as the target type {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoConstructorFound"> + <summary> + Looks up a localized string similar to The type {0} does not have an accessible constructor.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoMatchingGenericArgument"> + <summary> + Looks up a localized string similar to The type {0} does not have a generic argument named "{1}". + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoOperationExceptionReason"> + <summary> + Looks up a localized string similar to while resolving. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchConstructor"> + <summary> + Looks up a localized string similar to The type {0} does not have a constructor that takes the parameters ({1}).. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchMethod"> + <summary> + Looks up a localized string similar to The type {0} does not have a public method named {1} that takes the parameters ({2}).. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchProperty"> + <summary> + Looks up a localized string similar to The type {0} does not contain an instance property named {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NotAGenericType"> + <summary> + Looks up a localized string similar to The type {0} is not a generic type, and you are attempting to inject a generic parameter named "{1}".. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NotAnArrayTypeWithRankOne"> + <summary> + Looks up a localized string similar to The type {0} is not an array type with rank 1, and you are attempting to use a [DependencyArray] attribute on a parameter or property with this type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.OptionalDependenciesMustBeReferenceTypes"> + <summary> + Looks up a localized string similar to Optional dependencies must be reference types. The type {0} is a value type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyNotSettable"> + <summary> + Looks up a localized string similar to The property {0} on type {1} is not settable.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyTypeMismatch"> + <summary> + Looks up a localized string similar to The property {0} on type {1} is of type {2}, and cannot be injected with a value of type {3}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyValueResolutionFailed"> + <summary> + Looks up a localized string similar to The value for the property "{0}" could not be resolved.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ProvidedStringArgMustNotBeEmpty"> + <summary> + Looks up a localized string similar to The provided string argument must not be empty.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionFailed"> + <summary> + Looks up a localized string similar to Resolution of the dependency failed, type = "{0}", name = "{1}". + Exception occurred while: {2}. + Exception is: {3} - {4} + ----------------------------------------------- + At the time of the exception, the container was: + . + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionTraceDetail"> + <summary> + Looks up a localized string similar to Resolving {0},{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionWithMappingTraceDetail"> + <summary> + Looks up a localized string similar to Resolving {0},{1} (mapped from {2}, {3}). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolvingPropertyValueOperation"> + <summary> + Looks up a localized string similar to Resolving value for property {0}.{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.SelectedConstructorHasRefParameters"> + <summary> + Looks up a localized string similar to The constructor {1} selected for type {0} has ref or out parameters. Such parameters are not supported for constructor injection.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.SettingPropertyOperation"> + <summary> + Looks up a localized string similar to Setting value for property {0}.{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.TypeIsNotConstructable"> + <summary> + Looks up a localized string similar to The type {0} cannot be constructed. You must configure the container to supply this value.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.TypesAreNotAssignable"> + <summary> + Looks up a localized string similar to The type {1} cannot be assigned to variables of type {0}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.UnknownType"> + <summary> + Looks up a localized string similar to <unknown>. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainer"> + <summary> + A simple, extensible dependency injection container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.#ctor"> + <summary> + Create a default <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.#ctor(Microsoft.Practices.Unity.UnityContainer)"> + <summary> + Create a <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> with the given parent container. + </summary> + <param name="parent">The parent <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. The current object + will apply its own settings first, and then check the parent for additional ones.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + RegisterType a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + RegisterType an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <param name="lifetime"> + <para>If true, the container will take over the lifetime of the instance, + calling Dispose on it (if it's <see cref="T:System.IDisposable"/>) when the container is Disposed.</para> + <para> + If false, container will not maintain a strong reference to <paramref name="instance"/>. User is reponsible + for disposing instance, and for keeping the instance from being garbage collected.</para></param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Get an instance of the requested type with the given name from the container. + </summary> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="resolverOverrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <param name="t">The type requested.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <paramref name="t"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.BuildUp(System.Type,System.Object,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Teardown(System.Object)"> + <summary> + Run an existing object through the container, and clean it up. + </summary> + <param name="o">The object to tear down.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.AddExtension(Microsoft.Practices.Unity.UnityContainerExtension)"> + <summary> + Add an extension object to the container. + </summary> + <param name="extension"><see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Configure(System.Type)"> + <summary> + Get access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <param name="configurationInterface"><see cref="T:System.Type"/> of configuration interface required.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RemoveAllExtensions"> + <summary> + Remove all installed extensions from this container. + </summary> + <remarks> + <para> + This method removes all extensions from the container, including the default ones + that implement the out-of-the-box behavior. After this method, if you want to use + the container again you will need to either readd the default extensions or replace + them with your own. + </para> + <para> + The registered instances and singletons that have already been set up in this container + do not get removed. + </para> + </remarks> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.CreateChildContainer"> + <summary> + Create a child container. + </summary> + <remarks> + A child container shares the parent's configuration, but can be configured with different + settings or lifetime.</remarks> + <returns>The new child container.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Dispose"> + <summary> + Dispose this container instance. + </summary> + <remarks> + Disposing the container also disposes any child containers, + and disposes any instances whose lifetimes are managed + by the container. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Dispose(System.Boolean)"> + <summary> + Dispose this container instance. + </summary> + <remarks> + This class doesn't have a finalizer, so <paramref name="disposing"/> will always be true.</remarks> + <param name="disposing">True if being called from the IDisposable.Dispose + method, false if being called from a finalizer.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.ClearExistingBuildPlan(System.Type,System.String)"> + <summary> + Remove policies associated with building this type. This removes the + compiled build plan so that it can be rebuilt with the new settings + the next time this type is resolved. + </summary> + <param name="typeToInject">Type of object to clear the plan for.</param> + <param name="name">Name the object is being registered with.</param> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainer.Parent"> + <summary> + The parent of this container. + </summary> + <value>The parent container, or null if this container doesn't have one.</value> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainer.Registrations"> + <summary> + Get a sequence of <see cref="T:Microsoft.Practices.Unity.ContainerRegistration"/> that describe the current state + of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainer.ExtensionContextImpl"> + <summary> + Implementation of the ExtensionContext that is actually used + by the UnityContainer implementation. + </summary> + <remarks> + This is a nested class so that it can access state in the + container that would otherwise be inaccessible. + </remarks> + </member> + <member name="E:Microsoft.Practices.Unity.UnityContainer.ExtensionContextImpl.RegisteringInstance"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.UnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension"> + <summary> + This extension supplies the default behavior of the UnityContainer API + by handling the context events and setting policies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension.Initialize"> + <summary> + Install the default container behavior into the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension.Remove"> + <summary> + Remove the default behavior from the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityDefaultStrategiesExtension"> + <summary> + This extension installs the default strategies and policies into the container + to implement the standard behavior of the Unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultStrategiesExtension.Initialize"> + <summary> + Add the default ObjectBuilder strategies & policies to the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.MethodReflectionHelper"> + <summary> + Helper class to wrap common reflection stuff dealing with + methods. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.#ctor(System.Reflection.MethodBase)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.MethodReflectionHelper"/> instance that + lets us do more reflection stuff on that method. + </summary> + <param name="method">The method to reflect on.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.GetClosedParameterTypes(System.Type[])"> + <summary> + Given our set of generic type arguments, + </summary> + <param name="genericTypeArguments">The generic type arguments.</param> + <returns>An array with closed parameter types. </returns> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.MethodHasOpenGenericParameters"> + <summary> + Returns true if any of the parameters of this method + are open generics. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.ParameterTypes"> + <summary> + Return the <see cref="T:System.Type"/> of each parameter for this + method. + </summary> + <returns>Sequence of <see cref="T:System.Type"/> objects, one for + each parameter in order.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Pair`2"> + <summary> + A helper class that encapsulates two different + data items together into a a single item. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Pair`2.#ctor(`0,`1)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.Pair`2"/> containing + the two values give. + </summary> + <param name="first">First value</param> + <param name="second">Second value</param> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.Pair`2.First"> + <summary> + The first value of the pair. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.Pair`2.Second"> + <summary> + The second value of the pair. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Pair"> + <summary> + Container for a Pair helper method. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Pair.Make``2(``0,``1)"> + <summary> + A helper factory method that lets users take advantage of type inference. + </summary> + <typeparam name="TFirstParameter">Type of first value.</typeparam> + <typeparam name="TSecondParameter">Type of second value.</typeparam> + <param name="first">First value.</param> + <param name="second">Second value.</param> + <returns>A new <see cref="T:Microsoft.Practices.Unity.Utility.Pair`2"/> instance.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ParameterMatcher"> + <summary> + A utility class that handles the logic of matching parameter + lists, so we can find the right constructor and method overloads. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.#ctor(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue})"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.ParameterMatcher"/> that will attempt to + match the given parameter types. + </summary> + <param name="parametersToMatch">Target parameters to match against.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.Matches(System.Collections.Generic.IEnumerable{System.Type})"> + <summary> + Tests to see if the given set of types matches the ones + we're looking for. + </summary> + <param name="candidate">parameter list to look for.</param> + <returns>true if they match, false if they don't.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.Matches(System.Collections.Generic.IEnumerable{System.Reflection.ParameterInfo})"> + <summary> + Tests to see if the given set of types matches the ones we're looking for. + </summary> + <param name="candidate">Candidate method signature to look for.</param> + <returns>True if they match, false if they don't.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper"> + <summary> + Another reflection helper class that has extra methods + for dealing with ParameterInfos. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ReflectionHelper"> + <summary> + A small helper class to encapsulate details of the + reflection API, particularly around generics. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.ReflectionHelper"/> instance that + lets you look at information about the given type. + </summary> + <param name="typeToReflect">Type to do reflection on.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.MethodHasOpenGenericParameters(System.Reflection.MethodBase)"> + <summary> + Test the given <see cref="T:System.Reflection.MethodBase"/> object, looking at + the parameters. Determine if any of the parameters are + open generic types that need type attributes filled in. + </summary> + <param name="method">The method to check.</param> + <returns>True if any of the parameters are open generics. False if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.GetClosedParameterType(System.Type[])"> + <summary> + If this type is an open generic, use the + given <paramref name="genericArguments"/> array to + determine what the required closed type is and return that. + </summary> + <remarks>If the parameter is not an open type, just + return this parameter's type.</remarks> + <param name="genericArguments">Type arguments to substitute in for + the open type parameters.</param> + <returns>Corresponding closed type of this parameter.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.GetNamedGenericParameter(System.String)"> + <summary> + Given a generic argument name, return the corresponding type for this + closed type. For example, if the current type is SomeType<User>, and the + corresponding definition was SomeType<TSomething>, calling this method + and passing "TSomething" will return typeof(User). + </summary> + <param name="parameterName">Name of the generic parameter.</param> + <returns>Type of the corresponding generic parameter, or null if there + is no matching name.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"> + <summary> + The <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/> object we're reflecting over. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsGenericType"> + <summary> + Is this type generic? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsOpenGeneric"> + <summary> + Is this type an open generic (no type parameter specified) + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsArray"> + <summary> + Is this type an array type? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsGenericArray"> + <summary> + Is this type an array of generic elements? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.ArrayElementType"> + <summary> + The type of the elements in this type (if it's an array). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.InstanceConstructors"> + <summary> + Returns all the public constructors defined for the current reflected <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/>. + </summary> + <value> + An enumeration of <see cref="T:System.Reflection.ConstructorInfo"/> ConstructorInfo objects representing all the public instance constructors defined for the + current reflected <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/>, but not including the type initializer (static constructor). + </value> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper.#ctor(System.Reflection.ParameterInfo)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper"/> that + lets you query information about the given ParameterInfo object. + </summary> + <param name="parameter">Parameter to query.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.StaticReflection"> + <summary> + A set of helper methods to pick through lambdas and pull out + <see cref="T:System.Reflection.MethodInfo"/> from them. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMethodInfo(System.Linq.Expressions.Expression{System.Action})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object from an expression of the form + () => SomeClass.SomeMethod() + </summary> + <param name="expression">Expression describing the method to call.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMethodInfo``1(System.Linq.Expressions.Expression{System.Action{``0}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object from an expression of the form + x => x.SomeMethod() + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <param name="expression">Expression describing the method to call.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetPropertyGetMethodInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object for the get method from an expression of the form + x => x.SomeProperty + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <typeparam name="TProperty">The type for the property.</typeparam> + <param name="expression">Expression describing the property for which the get method is to be extracted.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetPropertySetMethodInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object for the set method from an expression of the form + x => x.SomeProperty + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <typeparam name="TProperty">The type for the property.</typeparam> + <param name="expression">Expression describing the property for which the set method is to be extracted.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMemberInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + + </summary> + <typeparam name="T"></typeparam> + <typeparam name="TProperty"></typeparam> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetConstructorInfo``1(System.Linq.Expressions.Expression{System.Func{``0}})"> + <summary> + Pull out a <see cref="T:System.Reflection.ConstructorInfo"/> object from an expression of the form () => new SomeType() + </summary> + <typeparam name="T">The type where the constructor is defined.</typeparam> + <param name="expression">Expression invoking the desired constructor.</param> + <returns>Corresponding <see cref="T:System.Reflection.ConstructorInfo"/>.</returns> + </member> + </members> +</doc>
Binary file src/packages/Unity.3.0.1304.1/lib/NetCore45/Microsoft.Practices.Unity.NetCore.dll has changed
Binary file src/packages/Unity.3.0.1304.1/lib/NetCore45/Microsoft.Practices.Unity.NetCore.pri has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Unity.3.0.1304.1/lib/NetCore45/Microsoft.Practices.Unity.NetCore.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,6049 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>Microsoft.Practices.Unity.NetCore</name> + </assembly> + <members> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that emits IL to call constructors + as part of creating a build plan. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"> + <summary> + Represents a strategy in the chain of responsibility. + Strategies are required to support both BuildUp and TearDown. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"> + <summary> + Represents a strategy in the chain of responsibility. + Strategies are required to support both BuildUp and TearDown. Although you + can implement this interface directly, you may also choose to use + <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> as the base class for your strategies, as + this class provides useful helper methods and makes support BuildUp and TearDown + optional. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PostTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PostTearDown method is called when the chain has finished the PreTearDown + phase and executes in reverse order from the PreTearDown calls. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PostTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PostTearDown method is called when the chain has finished the PreTearDown + phase and executes in reverse order from the PreTearDown calls. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <remarks>Existing object is an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext"/>.</remarks> + <param name="context">The context for the operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetPerBuildSingleton(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to set up a PerResolveLifetimeManager lifetime manager + if the current object is such. + </summary> + <param name="context">Current build context.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.CreateSignatureString(System.Reflection.ConstructorInfo)"> + <summary> + Build up the string that will represent the constructor signature + in any exception message. + </summary> + <param name="constructor"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetCurrentOperationToResolvingParameter(System.String,System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetCurrentOperationToInvokingConstructor(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForAttemptingToConstructInterface(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to throw an exception if + no existing object is present, but the user is attempting to build + an interface (usually due to the lack of a type mapping). + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForNullExistingObject(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to throw an exception if + a dependency cannot be resolved. + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForNullExistingObjectWithInvalidConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.String)"> + <summary> + A helper method used by the generated IL to throw an exception if + a dependency cannot be resolved because of an invalid constructor. + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + <param name="signature">The signature of the invalid constructor.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext"> + <summary> + + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.#ctor(System.Type)"> + <summary> + + </summary> + <param name="typeToBuild"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.AddToBuildPlan(System.Linq.Expressions.Expression)"> + <summary> + + </summary> + <param name="expression"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.CreateParameterExpression(System.String,System.Type,System.Linq.Expressions.Expression)"> + <summary> + + </summary> + <param name="parameterKey"></param> + <param name="parameterType"></param> + <param name="setOperationExpression"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type,System.String)"> + <summary> + Helper method used by generated IL to look up a dependency resolver based on the given key. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of the dependency being resolved.</param> + <param name="resolverKey">Key the resolver was stored under.</param> + <returns>The found dependency resolver.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.TypeToBuild"> + <summary> + The type that is to be built with the dynamic build plan. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.ContextParameter"> + <summary> + The context parameter represeting the <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> used when the build plan is executed. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanMethod"> + <summary> + + </summary> + <param name="context"></param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan"> + <summary> + + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy"> + <summary> + A build plan is an object that, when invoked, will create a new object + or fill in a given existing one. It encapsulates all the information + gathered by the strategies to construct a particular object. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"> + <summary> + Represents a builder policy interface. Since there are no fixed requirements + for policies, it acts as a marker interface from which to derive all other + policy interfaces. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan.#ctor(Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanMethod)"> + <summary> + + </summary> + <param name="buildMethod"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + + </summary> + <param name="context"></param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"/> implementation + that constructs a build plan via dynamic IL emission. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that can create and return an <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy"/> + for the given build key. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Create a build plan using the given context and build key. + </summary> + <param name="context">Current build context.</param> + <param name="buildKey">Current build key.</param> + <returns>The build plan.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy"/> that + uses the given strategy chain to construct the build plan. + </summary> + <param name="strategies">The strategy chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Construct a build plan. + </summary> + <param name="context">The current build context.</param> + <param name="buildKey">The current build key.</param> + <returns>The created build plan.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that generates IL to call + chosen methods (as specified by the current <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/>) + as part of object build up. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.SetCurrentOperationToResolvingParameter(System.String,System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.SetCurrentOperationToInvokingMethod(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that generates IL to resolve properties + on an object being built. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.SetCurrentOperationToResolvingPropertyValue(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.SetCurrentOperationToSettingProperty(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LazyDynamicMethodBuildPlanCreatorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"/> implementation + that constructs a build plan for creating <see cref="T:System.Lazy`1"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LazyDynamicMethodBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Creates a build plan using the given context and build key. + </summary> + <param name="context">Current build context.</param> + <param name="buildKey">Current build key.</param> + <returns> + The build plan. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.AllClasses"> + <summary> + Provides helper methods to retrieve classes from assemblies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Reflection.Assembly[])"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>. + </summary> + <param name="assemblies">The assemblies.</param> + <returns>All visible, non-abstract classes found in the assemblies.</returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks>All exceptions thrown while getting types from the assemblies are ignored, and the types that can be retrieved are returned.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Boolean,System.Reflection.Assembly[])"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>, and optionally skips errors. + </summary> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <param name="assemblies">The assemblies.</param> + <returns> + All visible, non-abstract classes. + </returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Collections.Generic.IEnumerable{System.Reflection.Assembly},System.Boolean)"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>. + </summary> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <param name="assemblies">The assemblies.</param> + <returns> + All visible, non-abstract classes. + </returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromApplication(System.Boolean,System.Boolean)"> + <summary> + Returns all visible, non-abstract classes from all assemblies located where the application is installed. + </summary> + <param name="includeUnityAssemblies"><see langword="false"/> to include the Unity assemblies; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <returns> + All visible, non-abstract classes. + </returns> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while loading assemblies or getting types from the assemblies + are ignored, and the types that can be retrieved are returned; otherwise, the original exception is thrown. These exceptions might be wrapped in a + <see cref="T:System.AggregateException"/>. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.DuplicateTypeMappingException"> + <summary> + The exception that is thrown when registering multiple types would result in an type mapping being overwritten. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DuplicateTypeMappingException.#ctor(System.String,System.Type,System.Type,System.Type)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.Unity.DuplicateTypeMappingException"/> class. + </summary> + <param name="name">The name for the mapping.</param> + <param name="mappedFromType">The source type for the mapping.</param> + <param name="currentMappedToType">The type currently mapped.</param> + <param name="newMappedToType">The new type to map.</param> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.Name"> + <summary> + Gets the name for the mapping. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.MappedFromType"> + <summary> + Gets the source type for the mapping. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.CurrentMappedToType"> + <summary> + Gets the type currently mapped. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.NewMappedToType"> + <summary> + Gets the new type to map. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.RegistrationConvention"> + <summary> + Represents a set of types to register and their registration settings. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetTypes"> + <summary> + Gets types to register. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetFromTypes"> + <summary> + Gets a function to get the types that will be requested for each type to configure. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetName"> + <summary> + Gets a function to get the name to use for the registration of each type. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetLifetimeManager"> + <summary> + Gets a function to get the <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the registration of each type. Defaults to no lifetime management. + </summary> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetInjectionMembers"> + <summary> + Gets a function to get the additional <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects for the registration of each type. Defaults to no injection members. + </summary> + <returns></returns> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions"> + <summary> + Provides a set of convenience overloads to the + <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> interface to support registration of multiple types. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions.RegisterTypes(Microsoft.Practices.Unity.IUnityContainer,System.Collections.Generic.IEnumerable{System.Type},System.Func{System.Type,System.Collections.Generic.IEnumerable{System.Type}},System.Func{System.Type,System.String},System.Func{System.Type,Microsoft.Practices.Unity.LifetimeManager},System.Func{System.Type,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionMember}},System.Boolean)"> + <summary> + Registers the supplied types by using the specified rules for name, lifetime manager, injection members, and registration types. + </summary> + <param name="container">The container to configure.</param> + <param name="types">The types to register. The methods in the <see cref="T:Microsoft.Practices.Unity.AllClasses"/> class can be used to scan assemblies to get types, and further filtering can be performed using LINQ queries.</param> + <param name="getFromTypes">A function that gets the types that will be requested for each type to configure. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithMappings"/> class or a custom function. Defaults to no registration types, and registers only the supplied types.</param> + <param name="getName">A function that gets the name to use for the registration of each type. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithName"/> or a custom function. Defaults to no name.</param> + <param name="getLifetimeManager">A function that gets the <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the registration of each type. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithLifetime"/> class or a custom function. Defaults to no lifetime management.</param> + <param name="getInjectionMembers">A function that gets the additional <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects for the registration of each type. Defaults to no injection members.</param> + <param name="overwriteExistingMappings"><see langword="true"/> to overwrite existing mappings; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <returns> + The container that this method was called on. + </returns> + <exception cref="T:System.ArgumentException">A new registration would overwrite an existing mapping and <paramref name="overwriteExistingMappings"/> is <see langword="false"/>.</exception> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions.RegisterTypes(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.RegistrationConvention,System.Boolean)"> + <summary> + Registers the types according to the <paramref name="convention"/>. + </summary> + <param name="container">The container to configure.</param> + <param name="convention">The convention to determine which types will be registered and how.</param> + <param name="overwriteExistingMappings"><see langword="true"/> to overwrite existing mappings; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <returns> + The container that this method was called on. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithLifetime"> + <summary> + Provides helper methods to specify the lifetime for a type with registration by convention. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.None(System.Type)"> + <summary> + Returns a <see langword="null"/> <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A lifetime manager</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.ContainerControlled(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A container controlled lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.ExternallyControlled(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>An externally controlled lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Hierarchical(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.HierarchicalLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A hierarchical lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.PerResolve(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A per resolve lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Transient(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.TransientLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A transient lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Custom``1(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="T">The custom <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> type.</typeparam> + <param name="type">The type.</param> + <returns> + A lifetime manager. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithMappings"> + <summary> + Provides helper methods to map types to the types interfaces to which register them. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.None(System.Type)"> + <summary> + Returns no types. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An empty enumeration.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromMatchingInterface(System.Type)"> + <summary> + Returns an enumeration with the interface that matches the name of <paramref name="implementationType"/>. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with the first interface matching the name of <paramref name="implementationType"/> (for example, if type is MyType, a matching interface is IMyType), + or an empty enumeration if no such interface is found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromAllInterfaces(System.Type)"> + <summary> + Returns an enumeration with all the interfaces implemented by <paramref name="implementationType"/>. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with all the interfaces implemented by the implementation type except <see cref="T:System.IDisposable"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromAllInterfacesInSameAssembly(System.Type)"> + <summary> + Returns an enumeration with all the interfaces implemented by <paramref name="implementationType"/> that belong to the same assembly as implementationType. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with all the interfaces implemented by the implementation type that belong to the same assembly.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithName"> + <summary> + Provides helper methods to get type names. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithName.TypeName(System.Type)"> + <summary> + Returns the type name. + </summary> + <param name="type">The type.</param> + <returns>The type name.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithName.Default(System.Type)"> + <summary> + Returns null for the registration name. + </summary> + <param name="type">The type.</param> + <returns><see langword="null"/></returns> + </member> + <member name="T:Microsoft.Practices.Unity.Properties.Resources"> + <summary> + A strongly-typed resource class, for looking up localized strings, etc. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResourceManager"> + <summary> + Returns the cached ResourceManager instance used by this class. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.AmbiguousInjectionConstructor"> + <summary> + The type {0} has multiple constructors of length {1}. Unable to disambig... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ArgumentMustNotBeEmpty"> + <summary> + The provided string argument must not be empty. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.BuildFailedException"> + <summary> + The current build operation (build key {2}) failed: {3} (Strategy type {... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotConstructInterface"> + <summary> + The current type {0} is an interface and cannot be constructed. Are you ... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotExtractTypeFromBuildKey"> + <summary> + Cannot extract type from build key {0}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectGenericMethod"> + <summary> + The method {0}.{1}({2}) is an open generic method. Open generic methods ... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectIndexer"> + <summary> + The property {0} on type {1} is an indexer. Indexed properties cannot be... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithOutParam"> + <summary> + The method {1} on type {0} has an out parameter. Injection cannot be per... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithOutParams"> + <summary> + The method {0}.{1}({2}) has at least one out parameter. Methods with out... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithRefParams"> + <summary> + The method {0}.{1}({2}) has at least one ref parameter.Methods with ref ... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectOpenGenericMethod"> + <summary> + The method {1} on type {0} is marked for injection but it is an open gen... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectStaticMethod"> + <summary> + The method {0}.{1}({2}) is static. Static methods cannot be injected. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotResolveOpenGenericType"> + <summary> + The type {0} is an open generic type. An open generic type cannot be res... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ConstructorArgumentResolveOperation"> + <summary> + Resolving parameter "{0}" of constructor {1} + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ConstructorParameterResolutionFailed"> + <summary> + The parameter {0} could not be resolved when attempting to call construc... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.DuplicateTypeMappingException"> + <summary> + An attempt to override an existing mapping was detected for type {1} wit... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ExceptionNullAssembly"> + <summary> + The set of assemblies contains a null element. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ExceptionNullParameterValue"> + <summary> + Parameter type inference does not work for null values. Indicate the par... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.InvokingConstructorOperation"> + <summary> + Calling constructor {0} + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.InvokingMethodOperation"> + <summary> + Calling method {0}.{1} + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.KeyAlreadyPresent"> + <summary> + An item with the given key is already present in the dictionary. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.LifetimeManagerInUse"> + <summary> + The lifetime manager is already registered. Lifetime managers cannot be ... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MarkerBuildPlanInvoked"> + <summary> + The override marker build plan policy has been invoked. This should neve... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MethodArgumentResolveOperation"> + <summary> + Resolving parameter "{0}" of method {1}.{2} + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MethodParameterResolutionFailed"> + <summary> + The value for parameter "{1}" of method {0} could not be resol... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MissingDependency"> + <summary> + Could not resolve dependency for build key {0}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MultipleInjectionConstructors"> + <summary> + The type {0} has multiple constructors marked with the InjectionConstruc... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MustHaveOpenGenericType"> + <summary> + The supplied type {0} must be an open generic type. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MustHaveSameNumberOfGenericArguments"> + <summary> + The supplied type {0} does not have the same number of generic arguments... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoConstructorFound"> + <summary> + The type {0} does not have an accessible constructor. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoMatchingGenericArgument"> + <summary> + The type {0} does not have a generic argument named "{1}" + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoOperationExceptionReason"> + <summary> + while resolving + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchConstructor"> + <summary> + The type {0} does not have a constructor that takes the parameters ({1}). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchMethod"> + <summary> + The type {0} does not have a public method named {1} that takes the para... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchProperty"> + <summary> + The type {0} does not contain an instance property named {1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NotAGenericType"> + <summary> + The type {0} is not a generic type and you are attempting to inject a ge... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NotAnArrayTypeWithRankOne"> + <summary> + The type {0} is not an array type with rank 1 and you are attempting to ... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.OptionalDependenciesMustBeReferenceTypes"> + <summary> + Optional dependencies must be reference types. The type {0} is a value t... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyNotSettable"> + <summary> + The property {0} on type {1} is not settable. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyTypeMismatch"> + <summary> + The property {0} on type {1} is of type {2} and cannot be injected with ... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyValueResolutionFailed"> + <summary> + The value for the property "{0}" could not be resolved. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ProvidedStringArgMustNotBeEmpty"> + <summary> + The provided string argument must not be empty. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionFailed"> + <summary> + Resolution of the dependency failed type = "{0}" name = "... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionTraceDetail"> + <summary> + Resolving {0}{1} + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionWithMappingTraceDetail"> + <summary> + Resolving {0}{1} (mapped from {2} {3}) + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolvingPropertyValueOperation"> + <summary> + Resolving value for property {0}.{1} + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.SelectedConstructorHasRefParameters"> + <summary> + The constructor {1} selected for type {0} has ref or out parameters. Suc... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.SettingPropertyOperation"> + <summary> + Setting value for property {0}.{1} + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.TypeIsNotConstructable"> + <summary> + The type {0} cannot be constructed. You must configure the container to ... + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.TypesAreNotAssignable"> + <summary> + The type {1} cannot be assigned to variables of type {0}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.UnknownType"> + <summary> + <unknown> + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions"> + <summary> + Provides extension methods to the <see cref="T:System.Type"/> class due to the introduction + of <see cref="T:System.Reflection.TypeInfo"/> class in the .NET for Windows Store apps. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetConstructor(System.Type,System.Type[])"> + <summary> + Returns the constructor in <paramref name="type"/> that matches the specified constructor parameter types. + </summary> + <param name="type">The type to inspect</param> + <param name="constructorParameters">The constructor parameter types.</param> + <returns>The constructor that matches the specified parameter types.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetMethodsHierarchical(System.Type)"> + <summary> + Returns the non-static declared methods of a type or its base types. + </summary> + <param name="type">The type to inspect</param> + <returns>An enumerable of the <see cref="T:System.Reflection.MethodInfo"/> objects.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetMethodHierarchical(System.Type,System.String,System.Type[])"> + <summary> + Returns the non-static method of a type or its based type. + </summary> + <param name="type">The type to inspect</param> + <param name="methodName">The name of the method to seek.</param> + <param name="closedParameters">The (closed) parameter type signature of the method.</param> + <returns>The discovered <see cref="T:System.Reflection.MethodInfo"/></returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetPropertiesHierarchical(System.Type)"> + <summary> + Returns the declared properties of a type or its base types. + </summary> + <param name="type">The type to inspect</param> + <returns>An enumerable of the <see cref="T:System.Reflection.PropertyInfo"/> objects.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.ParametersMatch(System.Reflection.ParameterInfo[],System.Type[])"> + <summary> + Determines if the types in a parameter set ordinally matches the set of supplied types. + </summary> + <param name="parameters"></param> + <param name="closedConstructorParameterTypes"></param> + <returns></returns> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyAttribute"> + <summary> + This attribute is used to mark properties and parameters as targets for injection. + </summary> + <remarks> + For properties, this attribute is necessary for injection to happen. For parameters, + it's not needed unless you want to specify additional information to control how + the parameter is resolved. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyResolutionAttribute"> + <summary> + Base class for attributes that can be placed on parameters + or properties to specify how to resolve the value for + that parameter or property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyResolutionAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.#ctor"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> with no name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.#ctor(System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> with the given name. + </summary> + <param name="name">Name to use when resolving this dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.DependencyAttribute.Name"> + <summary> + The name specified in the constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionConstructorAttribute"> + <summary> + This attribute is used to indicate which constructor to choose when + the container attempts to build a type. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMethodAttribute"> + <summary> + This attribute is used to mark methods that should be called when + the container is building an object. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.DependencyResolutionAttribute"/> used to mark a dependency + as optional - the container will try to resolve it, and return null + if the resolution fails rather than throw. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"/> object. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"/> object that + specifies a named dependency. + </summary> + <param name="name">Name of the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyAttribute.Name"> + <summary> + Name of the dependency. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.CompositeResolverOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that composites other + ResolverOverride objects. The GetResolver operation then + returns the resolver from the first child override that + matches the current context and request. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ResolverOverride"> + <summary> + Base class for all override objects passed in the + <see cref="M:Microsoft.Practices.Unity.IUnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"/> method. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.OnType``1"> + <summary> + Wrap this resolver in one that verifies the type of the object being built. + This allows you to narrow any override down to a specific type easily. + </summary> + <typeparam name="T">Type to constrain the override to.</typeparam> + <returns>The new override.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.OnType(System.Type)"> + <summary> + Wrap this resolver in one that verifies the type of the object being built. + This allows you to narrow any override down to a specific type easily. + </summary> + <param name="typeToOverride">Type to constrain the override to.</param> + <returns>The new override.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.Add(Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> to the collection + that is checked. + </summary> + <param name="newOverride">item to add.</param> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.AddRange(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a setof <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>s to the collection. + </summary> + <param name="newOverrides">items to add.</param> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ContainerRegistration"> + <summary> + Class that returns information about the types registered in a container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.RegisteredType"> + <summary> + The type that was passed to the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> method + as the "from" type, or the only type if type mapping wasn't done. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.MappedToType"> + <summary> + The type that this registration is mapped to. If no type mapping was done, the + <see cref="P:Microsoft.Practices.Unity.ContainerRegistration.RegisteredType"/> property and this one will have the same value. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.Name"> + <summary> + Name the type was registered under. Null for default registration. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.LifetimeManagerType"> + <summary> + The registered lifetime manager instance. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.LifetimeManager"> + <summary> + The lifetime manager for this registration. + </summary> + <remarks> + This property will be null if this registration is for an open generic.</remarks> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> class that overrides + the value injected whenever there is a dependency of the + given type, regardless of where it appears in the object graph. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride.#ctor(System.Type,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> to override + the given type with the given value. + </summary> + <param name="typeToConstruct">Type of the dependency.</param> + <param name="dependencyValue">Value to use.</param> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverride`1"> + <summary> + A convenience version of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> that lets you + specify the dependency type using generic syntax. + </summary> + <typeparam name="T">Type of the dependency to override.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride`1.#ctor(System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.DependencyOverride`1"/> object that will + override the given dependency, and pass the given value. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> that lets you + specify multiple parameter overrides in one shot rather than having + to construct multiple objects. + </summary> + <remarks> + This class isn't really a collection, it just implements IEnumerable + so that we get use of the nice C# collection initializer syntax. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.OverrideCollection`3"> + <summary> + Base helper class for creating collections of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects + for use in passing a bunch of them to the resolve call. This base class provides + the mechanics needed to allow you to use the C# collection initializer syntax. + </summary> + <typeparam name="TOverride">Concrete type of the <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> this class collects.</typeparam> + <typeparam name="TKey">Key used to create the underlying override object.</typeparam> + <typeparam name="TValue">Value that the override returns.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"> + <summary> + Add a new override to the collection with the given key and value. + </summary> + <param name="key">Key - for example, a parameter or property name.</param> + <param name="value">Value - the value to be returned by the override.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.MakeOverride(`1,`2)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverrides.MakeOverride(System.Type,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.ChildContainerCreated"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.#ctor(Microsoft.Practices.Unity.ExtensionContext)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs"/> object with the + given child container object. + </summary> + <param name="childContext">An <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> for the newly created child + container.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.ChildContainer"> + <summary> + The newly created child container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.ChildContext"> + <summary> + An extension context for the created child container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ExtensionContext"> + <summary> + The <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> class provides the means for extension objects + to manipulate the internal state of the <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ExtensionContext.RegisterNamedType(System.Type,System.String)"> + <summary> + Store a type/name pair for later resolution. + </summary> + <remarks> + <para> + When users register type mappings (or other things) with a named key, this method + allows you to register that name with the container so that when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"/> + method is called, that name is included in the list that is returned. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> to register.</param> + <param name="name">Name assocated with that type.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Container"> + <summary> + The container that this context is associated with. + </summary> + <value>The <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> object.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Strategies"> + <summary> + The strategies this container uses. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> that the container uses to build objects.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.BuildPlanStrategies"> + <summary> + The strategies this container uses to construct build plans. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> that this container uses when creating + build plans.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Policies"> + <summary> + The policies this container uses. + </summary> + <remarks>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> the that container uses to build objects.</remarks> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Lifetime"> + <summary> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> that this container uses. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> is used to manage <see cref="T:System.IDisposable"/> objects that the container is managing.</value> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.Registering"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.RegisteringInstance"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.ChildContainerCreated"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.CreateChildContainer"/> method is called, providing + the newly created child container to extensions to act on as they see fit. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.IUnityContainerExtensionConfigurator"> + <summary> + Base interface for all extension configuration interfaces. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainerExtensionConfigurator.Container"> + <summary> + Retrieve the container instance that we are currently configuring. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.NamedEventArgs"> + <summary> + An EventArgs class that holds a string Name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.NamedEventArgs.#ctor"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.NamedEventArgs"/> with a null name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.NamedEventArgs.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.NamedEventArgs"/> with the given name. + </summary> + <param name="name">Name to store.</param> + </member> + <member name="P:Microsoft.Practices.Unity.NamedEventArgs.Name"> + <summary> + The name. + </summary> + <value>Name used for this event arg object.</value> + </member> + <member name="T:Microsoft.Practices.Unity.RegisterEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.Registering"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterEventArgs.#ctor(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.RegisterEventArgs"/>. + </summary> + <param name="typeFrom">Type to map from.</param> + <param name="typeTo">Type to map to.</param> + <param name="name">Name for the registration.</param> + <param name="lifetimeManager"><see cref="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"/> to manage instances.</param> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.TypeFrom"> + <summary> + Type to map from. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.TypeTo"> + <summary> + Type to map to. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"> + <summary> + <see cref="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"/> to manage instances. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.RegisteringInstance"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterInstanceEventArgs.#ctor"> + <summary> + Create a default <see cref="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"/> instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterInstanceEventArgs.#ctor(System.Type,System.Object,System.String,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Create a <see cref="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"/> instance initialized with the given arguments. + </summary> + <param name="registeredType">Type of instance being registered.</param> + <param name="instance">The instance object itself.</param> + <param name="name">Name to register under, null if default registration.</param> + <param name="lifetimeManager"><see cref="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.LifetimeManager"/> object that handles how + the instance will be owned.</param> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.RegisteredType"> + <summary> + Type of instance being registered. + </summary> + <value> + Type of instance being registered. + </value> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.Instance"> + <summary> + Instance object being registered. + </summary> + <value>Instance object being registered</value> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.LifetimeManager"> + <summary> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls ownership of + this instance. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerExtension"> + <summary> + Base class for all <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> extension objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.InitializeExtension(Microsoft.Practices.Unity.ExtensionContext)"> + <summary> + The container calls this method when the extension is added. + </summary> + <param name="context">A <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> instance that gives the + extension access to the internals of the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.Initialize"> + <summary> + Initial the container with this extension's functionality. + </summary> + <remarks> + When overridden in a derived class, this method will modify the given + <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> by adding strategies, policies, etc. to + install it's functions into the container.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.Remove"> + <summary> + Removes the extension's functions from the container. + </summary> + <remarks> + <para> + This method is called when extensions are being removed from the container. It can be + used to do things like disconnect event handlers or clean up member state. You do not + need to remove strategies or policies here; the container will do that automatically. + </para> + <para> + The default implementation of this method does nothing.</para> + </remarks> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainerExtension.Container"> + <summary> + The container this extension has been added to. + </summary> + <value>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> that this extension has been added to.</value> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainerExtension.Context"> + <summary> + The <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> object used to manipulate + the inner state of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.GenericParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an instance of a generic type parameter should be resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.GenericParameterBase"> + <summary> + Base class for <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> subclasses that let you specify that + an instance of a generic type parameter should be resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameterValue"> + <summary> + Base type for objects that are used to configure parameters for + constructor or method injection, or for getting the value to + be injected into a property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameters(System.Object[])"> + <summary> + Convert the given set of arbitrary values to a sequence of InjectionParameterValue + objects. The rules are: If it's already an InjectionParameterValue, return it. If + it's a Type, return a ResolvedParameter object for that type. Otherwise return + an InjectionParameter object for that value. + </summary> + <param name="values">The values to build the sequence from.</param> + <returns>The resulting converted sequence.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameter(System.Object)"> + <summary> + Convert an arbitrary value to an InjectionParameterValue object. The rules are: + If it's already an InjectionParameterValue, return it. If it's a Type, return a + ResolvedParameter object for that type. Otherwise return an InjectionParameter + object for that value. + </summary> + <param name="value">The value to convert.</param> + <returns>The resulting <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.InjectionParameterValue.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.GenericParameterBase.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.GenericResolvedArrayParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an array containing the registered instances of a generic type parameter + should be resolved. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.#ctor(System.String,System.Object[])"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericResolvedArrayParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + <remarks>A type is considered compatible if it is an array type of rank one + and its element type is a generic type parameter with a name matching this generic + parameter name configured for the receiver.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.GenericResolvedArrayParameter.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectedMembers"> + <summary> + A Unity container extension that allows you to configure + which constructors, properties, and methods get injected + via an API rather than through attributes. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.Initialize"> + <summary> + Initial the container with this extension's functionality. + </summary> + <remarks> + When overridden in a derived class, this method will modify the given + <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> by adding strategies, policies, etc. to + install it's functions into the container.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor``1(Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type. + </summary> + <typeparam name="TTypeToInject">Type the injection is being configured for.</typeparam> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor``1(System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <typeparam name="TTypeToInject">Type the injection is being configured for.</typeparam> + <param name="name">Name of registration</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type. + </summary> + <param name="typeToInject">Type to configure.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <param name="typeToInject">Type to configure.</param> + <param name="name">Name of registration.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <param name="serviceType">Type of interface/base class being registered (may be null).</param> + <param name="implementationType">Type of actual implementation class being registered.</param> + <param name="name">Name of registration.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionConstructor"> + <summary> + A class that holds the collection of information + for a constructor, so that the container can + be configured to call this constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMember"> + <summary> + Base class for objects that can be used to configure what + class members get injected by the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMember.AddPolicies(System.Type,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="typeToCreate">Type to register.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMember.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface being registered. If no interface, + this will be null.</param> + <param name="implementationType">Type of concrete type being registered.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionConstructor.#ctor(System.Object[])"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionConstructor"/> that looks + for a constructor with the given set of parameters. + </summary> + <param name="parameterValues">The values for the parameters, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionConstructor.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Interface registered, ignored in this implementation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionFactory"> + <summary> + A class that lets you specify a factory method the container + will use to create the object. + </summary> + <remarks>This is a significantly easier way to do the same + thing the old static factory extension was used for.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.#ctor(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionFactory"/> with + the given factory function. + </summary> + <param name="factoryFunc">Factory function.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.#ctor(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,System.Object})"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionFactory"/> with + the given factory function. + </summary> + <param name="factoryFunc">Factory function.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface being registered. If no interface, + this will be null. This parameter is ignored in this implementation.</param> + <param name="implementationType">Type of concrete type being registered.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMethod"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> that configures the + container to call a method as part of buildup. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.#ctor(System.String,System.Object[])"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.InjectionMethod"/> instance which will configure + the container to call the given methods with the given parameters. + </summary> + <param name="methodName">Name of the method to call.</param> + <param name="methodParameters">Parameter values for the method.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface registered, ignored in this implementation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.MethodNameMatches(System.Reflection.MemberInfo,System.String)"> + <summary> + A small function to handle name matching. You can override this + to do things like case insensitive comparisons. + </summary> + <param name="targetMethod">MethodInfo for the method you're checking.</param> + <param name="nameToMatch">Name of the method you're looking for.</param> + <returns>True if a match, false if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameter"> + <summary> + A class that holds on to the given value and provides + the required <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> + when the container is configured. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.TypedInjectionValue"> + <summary> + A base class for implementing <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> classes + that deal in explicit types. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TypedInjectionValue.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.TypedInjectionValue"/> that exposes + information about the given <paramref name="parameterType"/>. + </summary> + <param name="parameterType">Type of the parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TypedInjectionValue.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.TypedInjectionValue.ParameterType"> + <summary> + The type of parameter this object represents. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.TypedInjectionValue.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.#ctor(System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that stores + the given value, using the runtime type of that value as the + type of the parameter. + </summary> + <param name="parameterValue">Value to be injected for this parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.#ctor(System.Type,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that stores + the given value, associated with the given type. + </summary> + <param name="parameterType">Type of the parameter.</param> + <param name="parameterValue">Value of the parameter</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that makes it a + little easier to specify the type of the parameter. + </summary> + <typeparam name="TParameter">Type of parameter.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter`1.#ctor(`0)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.InjectionParameter`1"/>. + </summary> + <param name="parameterValue">Value for the parameter.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionProperty"> + <summary> + This class stores information about which properties to inject, + and will configure the container accordingly. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.#ctor(System.String)"> + <summary> + Configure the container to inject the given property name, + resolving the value via the container. + </summary> + <param name="propertyName">Name of the property to inject.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.#ctor(System.String,System.Object)"> + <summary> + Configure the container to inject the given property name, + using the value supplied. This value is converted to an + <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object using the + rules defined by the <see cref="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameters(System.Object[])"/> + method. + </summary> + <param name="propertyName">Name of property to inject.</param> + <param name="propertyValue">Value for property.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Interface being registered, ignored in this implemenation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalGenericParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an instance of a generic type parameter should be resolved, providing the <see langword="null"/> + value if resolving fails. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that can be passed to + <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> to configure a + parameter or property as an optional dependency. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter"/> object that + specifies the given <paramref name="type"/>. + </summary> + <param name="type">Type of the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter"/> object that + specifies the given <paramref name="type"/> and <paramref name="name"/>. + </summary> + <param name="type">Type of the dependency.</param> + <param name="name">Name for the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.OptionalParameter"></see> that lets you + specify the type of the dependency using generics syntax. + </summary> + <typeparam name="T">Type of the dependency.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter`1.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter`1"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter`1.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter`1"/> with the given + <paramref name="name"/>. + </summary> + <param name="name">Name of the dependency.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayParameter"> + <summary> + A class that stores a type, and generates a + resolver object that resolves all the named instances or the + type registered in a container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.#ctor(System.Type,System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> that + resolves to the given element type and collection of element values. + </summary> + <param name="elementType">The type of elements to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.#ctor(System.Type,System.Type,System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> that + resolves to the given array and element types and collection of element values. + </summary> + <param name="arrayParameterType">The type for the array of elements to resolve.</param> + <param name="elementType">The type of elements to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> for convenience + when creating them by hand. + </summary> + <typeparam name="TElement">Type of the elements for the array of the parameter.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter`1.#ctor(System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter`1"/> that + resolves to the given element generic type with the given element values. + </summary> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedParameter"> + <summary> + A class that stores a name and type, and generates a + resolver object that resolves the parameter via the + container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> that + resolves to the given type. + </summary> + <param name="parameterType">Type of this parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> that + resolves the given type and name. + </summary> + <param name="parameterType">Type of this parameter.</param> + <param name="name">Name to use when resolving parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> for convenience + when creating them by hand. + </summary> + <typeparam name="TParameter">Type of the parameter</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter`1.#ctor"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter`1"/> for the given + generic type and the default name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter`1.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter`1"/> for the given + generic type and name. + </summary> + <param name="name">Name to use to resolve this parameter.</param> + </member> + <member name="T:Microsoft.Practices.Unity.IUnityContainer"> + <summary> + Interface defining the behavior of the Unity dependency injection container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <param name="lifetime"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the requested type with the given name from the container. + </summary> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="resolverOverrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <param name="t">The type requested.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <paramref name="t"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.BuildUp(System.Type,System.Object,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Teardown(System.Object)"> + <summary> + Run an existing object through the container, and clean it up. + </summary> + <param name="o">The object to tear down.</param> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.AddExtension(Microsoft.Practices.Unity.UnityContainerExtension)"> + <summary> + Add an extension object to the container. + </summary> + <param name="extension"><see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Configure(System.Type)"> + <summary> + Resolve access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <param name="configurationInterface"><see cref="T:System.Type"/> of configuration interface required.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RemoveAllExtensions"> + <summary> + Remove all installed extensions from this container. + </summary> + <remarks> + <para> + This method removes all extensions from the container, including the default ones + that implement the out-of-the-box behavior. After this method, if you want to use + the container again you will need to either readd the default extensions or replace + them with your own. + </para> + <para> + The registered instances and singletons that have already been set up in this container + do not get removed. + </para> + </remarks> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.CreateChildContainer"> + <summary> + Create a child container. + </summary> + <remarks> + A child container shares the parent's configuration, but can be configured with different + settings or lifetime.</remarks> + <returns>The new child container.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainer.Parent"> + <summary> + The parent of this container. + </summary> + <value>The parent container, or null if this container doesn't have one.</value> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainer.Registrations"> + <summary> + Get a sequence of <see cref="T:Microsoft.Practices.Unity.ContainerRegistration"/> that describe the current state + of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that holds onto the instance given to it. + When the <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/> is disposed, + the instance is disposed with it. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.SynchronizedLifetimeManager"> + <summary> + Base class for Lifetime managers which need to synchronize calls to + <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/>. + </summary> + <remarks> + <para> + The purpose of this class is to provide a basic implementation of the lifetime manager synchronization pattern. + </para> + <para> + Calls to the <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/> method of a <see cref="T:Microsoft.Practices.Unity.SynchronizedLifetimeManager"/> + instance acquire a lock, and if the instance has not been initialized with a value yet the lock will only be released + when such an initialization takes place by calling the <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"/> method or if + the build request which resulted in the call to the GetValue method fails. + </para> + </remarks> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> + </member> + <member name="T:Microsoft.Practices.Unity.LifetimeManager"> + <summary> + Base class for Lifetime managers - classes that control how + and when instances are created by the Unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that controls how instances are + persisted and recovered from an external store. Used to implement + things like singletons and per-http-request lifetime. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object to store.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.RemoveValue"> + <summary> + Remove the value this lifetime policy is managing from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"> + <summary> + This interface provides a hook for the builder context to + implement error recovery when a builder strategy throws + an exception. Since we can't get try/finally blocks onto + the call stack for later stages in the chain, we instead + add these objects to the context. If there's an exception, + all the current IRequiresRecovery instances will have + their Recover methods called. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"> + <summary> + A method that does whatever is needed to clean up + as part of cleaning up after an exception. + </summary> + <remarks> + Don't do anything that could throw in this method, + it will cause later recover operations to get skipped + and play real havoc with the stack trace. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + <remarks>Calls to this method acquire a lock which is released only if a non-null value + has been set for the lifetime manager.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SynchronizedGetValue"> + <summary> + Performs the actual retrieval of a value from the backing store associated + with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + <remarks>This method is invoked by <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/> + after it has acquired its lock.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + <remarks>Setting a value will attempt to release the lock acquired by + <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/>.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SynchronizedSetValue(System.Object)"> + <summary> + Performs the actual storage of the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + <remarks>This method is invoked by <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"/> + before releasing its lock.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.Recover"> + <summary> + A method that does whatever is needed to clean up + as part of cleaning up after an exception. + </summary> + <remarks> + Don't do anything that could throw in this method, + it will cause later recover operations to get skipped + and play real havoc with the stack trace. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.SynchronizedGetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.SynchronizedSetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.Dispose"> + <summary> + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + </summary> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.Dispose(System.Boolean)"> + <summary> + Standard Dispose pattern implementation. Not needed, but it keeps FxCop happy. + </summary> + <param name="disposing">Always true, since we don't have a finalizer.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that holds a weak reference to + it's managed instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.HierarchicalLifetimeManager"> + <summary> + A special lifetime manager which works like <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/>, + except that in the presence of child containers, each child gets it's own instance + of the object, instead of sharing one in the common parent. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.LifetimeManagerFactory"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy"/> that + creates instances of the type of the given Lifetime Manager + by resolving them through the container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy"> + <summary> + A builder policy used to create lifetime policy instances. + Used by the LifetimeStrategy when instantiating open + generic types. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy.CreateLifetimePolicy"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/>. + </summary> + <returns>The new instance.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy.LifetimeType"> + <summary> + The type of Lifetime manager that will be created by this factory. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManagerFactory.#ctor(Microsoft.Practices.Unity.ExtensionContext,System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.LifetimeManagerFactory"/> that will + return instances of the given type, creating them by + resolving through the container. + </summary> + <param name="containerContext">Container to resolve with.</param> + <param name="lifetimeType">Type of LifetimeManager to create.</param> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManagerFactory.CreateLifetimePolicy"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/>. + </summary> + <returns>The new instance.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.LifetimeManagerFactory.LifetimeType"> + <summary> + The type of Lifetime manager that will be created by this factory. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"> + <summary> + This is a custom lifetime manager that acts like <see cref="T:Microsoft.Practices.Unity.TransientLifetimeManager"/>, + but also provides a signal to the default build plan, marking the type so that + instances are reused across the build up object graph. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/> object that does not + itself manage an instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.#ctor(System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/> object that stores the + give value. This value will be returned by <see cref="M:Microsoft.Practices.Unity.LifetimeManager.GetValue"/> + but is not stored in the lifetime manager, nor is the value disposed. + This Lifetime manager is intended only for internal use, which is why the + normal <see cref="M:Microsoft.Practices.Unity.LifetimeManager.SetValue(System.Object)"/> method is not used here. + </summary> + <param name="value">Value to store.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. In this class, + this is a noop, since it has special hooks down in the guts. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. Noop in this class. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.TransientLifetimeManager"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> implementation that does nothing, + thus ensuring that instances are created new every time. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ArrayResolutionStrategy"> + <summary> + This strategy implements the logic that will call container.ResolveAll + when an array parameter is detected. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ArrayResolutionStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Do the PreBuildUp stage of construction. This is where the actual work is performed. + </summary> + <param name="context">Current build context.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityConstructorSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that is + aware of the build keys used by the Unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that, when implemented, + will determine which constructor to call from the build plan. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.ConstructorLengthComparer.Compare(System.Reflection.ConstructorInfo,System.Reflection.ConstructorInfo)"> + <summary> + Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + </summary> + + <returns> + Value Condition Less than zerox is less than y.Zerox equals y.Greater than zerox is greater than y. + </returns> + + <param name="y">The second object to compare.</param> + <param name="x">The first object to compare.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityConstructorSelectorPolicy.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <remarks> + This implementation looks for the Unity <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> on the + parameter and uses it to create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"/> + for this parameter.</remarks> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityMethodSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> that is aware + of the build keys used by the Unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + <typeparam name="TMarkerAttribute">Attribute that marks methods that should + be called.</typeparam> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that will examine the given + types and return a sequence of <see cref="T:System.Reflection.MethodInfo"/> objects + that should be called as part of building the object. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityMethodSelectorPolicy.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityPropertySelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> that is aware of + the build keys used by the unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that returns a sequence + of properties that should be injected for the given type. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityPropertySelectorPolicy.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.HierarchicalLifetimeStrategy"> + <summary> + A strategy that handles Hierarchical lifetimes across a set of parent/child + containers. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.HierarchicalLifetimeStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> implementation that returns + the value set in the constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that is used at build plan execution time + to resolve a dependent value. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy.#ctor(System.Object)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy"/> + which will return the given value when resolved. + </summary> + <param name="dependencyValue">The value to return.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that stores a + type and name, and at resolution time puts them together into a + <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.#ctor(System.Type,System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"/> + with the given type and name. + </summary> + <param name="type">The type.</param> + <param name="name">The name (may be null).</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Resolve the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Type"> + <summary> + The type that this resolver resolves. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Name"> + <summary> + The name that this resolver resolves. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that will attempt to + resolve a value, and return null if it cannot rather than throwing. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"/> object + that will attempt to resolve the given name and type from the container. + </summary> + <param name="type">Type to resolve. Must be a reference type.</param> + <param name="name">Name to resolve with.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"/> object + that will attempt to resolve the given type from the container. + </summary> + <param name="type">Type to resolve. Must be a reference type.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.DependencyType"> + <summary> + Type this resolver will resolve. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.Name"> + <summary> + Name this resolver will resolve. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that resolves to + to an array populated with the values that result from resolving other instances + of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy.#ctor(System.Type,Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy[])"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy"/> + with the given type and a collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> + instances to use when populating the result. + </summary> + <param name="elementType">The type.</param> + <param name="elementPolicies">The resolver policies to use when populating an array.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Resolve the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>An array pupulated with the results of resolving the resolver policies.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that selects + the given constructor and creates the appropriate resolvers to call it with + the specified parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy.#ctor(System.Reflection.ConstructorInfo,Microsoft.Practices.Unity.InjectionParameterValue[])"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy"/> that + will return the given constructor, being passed the given injection values + as parameters. + </summary> + <param name="ctor">The constructor to call.</param> + <param name="parameterValues">Set of <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects + that describes how to obtain the values for the constructor parameters.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMemberSelectorHelper"> + <summary> + Helper class for implementing selector policies that need to + set up dependency resolver policies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMemberSelectorHelper.AddParameterResolvers(System.Type,Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue},Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters)"> + <summary> + Add dependency resolvers to the parameter set. + </summary> + <param name="typeToBuild">Type that's currently being built (used to resolve open generics).</param> + <param name="policies">PolicyList to add the resolvers to.</param> + <param name="parameterValues">Objects supplying the dependency resolvers.</param> + <param name="result">Result object to store the keys in.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> implementation that calls the specific + methods with the given parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy.AddMethodAndParameters(System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue})"> + <summary> + Add the given method and parameter collection to the list of methods + that will be returned when the selector's <see cref="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/> + method is called. + </summary> + <param name="method">Method to call.</param> + <param name="parameters">sequence of <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects + that describe how to create the method parameter values.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy"> + <summary> + An implemnetation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> which returns + the set of specific properties that the selector was configured with. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.AddPropertyAndValue(System.Reflection.PropertyInfo,Microsoft.Practices.Unity.InjectionParameterValue)"> + <summary> + Add a property that will be par of the set returned when the + <see cref="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/> is called. + </summary> + <param name="property">The property to set.</param> + <param name="value"><see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object describing + how to create the value to inject.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage"> + <summary> + The build stages we use in the Unity container + strategy pipeline. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Setup"> + <summary> + First stage. By default, nothing happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.TypeMapping"> + <summary> + Second stage. Type mapping occurs here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Lifetime"> + <summary> + Third stage. lifetime managers are checked here, + and if they're available the rest of the pipeline is skipped. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.PreCreation"> + <summary> + Fourth stage. Reflection over constructors, properties, etc. is + performed here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Creation"> + <summary> + Fifth stage. Instance creation happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Initialization"> + <summary> + Sixth stage. Property sets and method injection happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.PostInitialization"> + <summary> + Seventh and final stage. By default, nothing happens here. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"> + <summary> + Represents the context in which a build-up or tear-down operation runs. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"> + <summary> + Represents the context in which a build-up or tear-down operation runs. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.AddResolverOverrides(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a new set of resolver override objects to the current build operation. + </summary> + <param name="newOverrides"><see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.GetOverriddenResolver(System.Type)"> + <summary> + Get a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object for the given <paramref name="dependencyType"/> + or null if that dependency hasn't been overridden. + </summary> + <param name="dependencyType">Type of the dependency.</param> + <returns>Resolver to use, or null if no override matches for the current operation.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + A convenience method to do a new buildup operation on an existing context. + </summary> + <param name="newBuildKey">Key to use to build up.</param> + <returns>Created object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Action{Microsoft.Practices.ObjectBuilder2.IBuilderContext})"> + <summary> + A convenience method to do a new buildup operation on an existing context. This + overload allows you to specify extra policies which will be in effect for the duration + of the build. + </summary> + <param name="newBuildKey">Key defining what to build up.</param> + <param name="childCustomizationBlock">A delegate that takes a <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/>. This + is invoked with the new child context before the build up process starts. This gives callers + the opportunity to customize the context for the build process.</param> + <returns>Created object.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Strategies"> + <summary> + Gets the head of the strategy chain. + </summary> + <returns> + The strategy that's first in the chain; returns null if there are no + strategies in the chain. + </returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Lifetime"> + <summary> + Gets the <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </summary> + <value> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.OriginalBuildKey"> + <summary> + Gets the original build key for the build operation. + </summary> + <value> + The original build key for the build operation. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.BuildKey"> + <summary> + Get the current build key for the current build operation. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.PersistentPolicies"> + <summary> + The set of policies that were passed into this context. + </summary> + <remarks>This returns the policies passed into the context. + Policies added here will remain after buildup completes.</remarks> + <value>The persistent policies for the current context.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Policies"> + <summary> + Gets the policies for the current context. + </summary> + <remarks>Any policies added to this object are transient + and will be erased at the end of the buildup.</remarks> + <value> + The policies for the current context. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.RecoveryStack"> + <summary> + Gets the collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> objects + that need to execute in event of an exception. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Existing"> + <summary> + The current object being built up or torn down. + </summary> + <value> + The current object being manipulated by the build operation. May + be null if the object hasn't been created yet.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.BuildComplete"> + <summary> + Flag indicating if the build operation should continue. + </summary> + <value>true means that building should not call any more + strategies, false means continue to the next strategy.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.CurrentOperation"> + <summary> + An object representing what is currently being done in the + build chain. Used to report back errors if there's a failure. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.ChildContext"> + <summary> + The build context used to resolve a dependency during the build operation represented by this context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor(Microsoft.Practices.ObjectBuilder2.IStrategyChain,Microsoft.Practices.ObjectBuilder2.ILifetimeContainer,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Object)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> class with a <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>, + <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/>, <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> and the + build key used to start this build operation. + </summary> + <param name="chain">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/> to use for this context.</param> + <param name="lifetime">The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> to use for this context.</param> + <param name="policies">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to use for this context.</param> + <param name="originalBuildKey">Build key to start building.</param> + <param name="existing">The existing object to build up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor(Microsoft.Practices.ObjectBuilder2.IStrategyChain,Microsoft.Practices.ObjectBuilder2.ILifetimeContainer,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Object)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> using the explicitly provided + values. + </summary> + <param name="chain">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/> to use for this context.</param> + <param name="lifetime">The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> to use for this context.</param> + <param name="persistentPolicies">The set of persistent policies to use for this context.</param> + <param name="transientPolicies">The set of transient policies to use for this context. It is + the caller's responsibility to ensure that the transient and persistent policies are properly + combined.</param> + <param name="buildKey">Build key for this context.</param> + <param name="existing">Existing object to build up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.AddResolverOverrides(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a new set of resolver override objects to the current build operation. + </summary> + <param name="newOverrides"><see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.GetOverriddenResolver(System.Type)"> + <summary> + Get a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object for the given <paramref name="dependencyType"/> + or null if that dependency hasn't been overridden. + </summary> + <param name="dependencyType">Type of the dependency.</param> + <returns>Resolver to use, or null if no override matches for the current operation.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + A convenience method to do a new buildup operation on an existing context. + </summary> + <param name="newBuildKey">Key to use to build up.</param> + <returns>Created object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Action{Microsoft.Practices.ObjectBuilder2.IBuilderContext})"> + <summary> + A convenience method to do a new buildup operation on an existing context. This + overload allows you to specify extra policies which will be in effect for the duration + of the build. + </summary> + <param name="newBuildKey">Key defining what to build up.</param> + <param name="childCustomizationBlock">A delegate that takes a <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/>. This + is invoked with the new child context before the build up process starts. This gives callers + the opportunity to customize the context for the build process.</param> + <returns>Created object.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Strategies"> + <summary> + Gets the head of the strategy chain. + </summary> + <returns> + The strategy that's first in the chain; returns null if there are no + strategies in the chain. + </returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.BuildKey"> + <summary> + Get the current build key for the current build operation. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Existing"> + <summary> + The current object being built up or torn down. + </summary> + <value> + The current object being manipulated by the build operation. May + be null if the object hasn't been created yet.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Lifetime"> + <summary> + Gets the <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </summary> + <value> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.OriginalBuildKey"> + <summary> + Gets the original build key for the build operation. + </summary> + <value> + The original build key for the build operation. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.PersistentPolicies"> + <summary> + The set of policies that were passed into this context. + </summary> + <remarks>This returns the policies passed into the context. + Policies added here will remain after buildup completes.</remarks> + <value>The persistent policies for the current context.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Policies"> + <summary> + Gets the policies for the current context. + </summary> + <remarks> + Any modifications will be transient (meaning, they will be forgotten when + the outer BuildUp for this context is finished executing). + </remarks> + <value> + The policies for the current context. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.RecoveryStack"> + <summary> + Gets the collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> objects + that need to execute in event of an exception. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.BuildComplete"> + <summary> + Flag indicating if the build operation should continue. + </summary> + <value>true means that building should not call any more + strategies, false means continue to the next strategy.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.CurrentOperation"> + <summary> + An object representing what is currently being done in the + build chain. Used to report back errors if there's a failure. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.ChildContext"> + <summary> + The build context used to resolve a dependency during the build operation represented by this context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"> + <summary> + Represents that a dependency could not be resolved. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with no extra information. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the given message. + </summary> + <param name="message">Some random message.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.String,System.Exception)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the given + message and inner exception. + </summary> + <param name="message">Some random message</param> + <param name="innerException">Inner exception.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the build key of the object begin built. + </summary> + <param name="buildKey">The build key of the object begin built.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"> + <summary> + The exception thrown when injection is attempted on a method + that is an open generic or has out or ref params. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with no + message. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor(System.String)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with the given message + </summary> + <param name="message">Message to return.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor(System.String,System.Exception)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with the given message + and inner exception. + </summary> + <param name="message">Message to return.</param> + <param name="innerException">Inner exception</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions"> + <summary> + Extension methods to provide convenience overloads over the + <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> interface. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.NewBuildUp``1(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Start a recursive build up operation to retrieve the default + value for the given <typeparamref name="TResult"/> type. + </summary> + <typeparam name="TResult">Type of object to build.</typeparam> + <param name="context">Parent context.</param> + <returns>Resulting object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.NewBuildUp``1(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.String)"> + <summary> + Start a recursive build up operation to retrieve the named + implementation for the given <typeparamref name="TResult"/> type. + </summary> + <typeparam name="TResult">Type to resolve.</typeparam> + <param name="context">Parent context.</param> + <param name="name">Name to resolve with.</param> + <returns>The resulting object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.AddResolverOverrides(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Add a set of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>s to the context, specified as a + variable argument list. + </summary> + <param name="context">Context to add overrides to.</param> + <param name="overrides">The overrides.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IRecoveryStack"> + <summary> + Data structure that stores the set of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> + objects and executes them when requested. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.Add(Microsoft.Practices.ObjectBuilder2.IRequiresRecovery)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> object to this + list. + </summary> + <param name="recovery">Object to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.ExecuteRecovery"> + <summary> + Execute the <see cref="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"/> method + of everything in the recovery list. Recoveries will execute + in the opposite order of add - it's a stack. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.Count"> + <summary> + Return the number of recovery objects currently in the stack. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"> + <summary> + Represents a lifetime container. + </summary> + <remarks> + A lifetime container tracks the lifetime of an object, and implements + IDisposable. When the container is disposed, any objects in the + container which implement IDisposable are also disposed. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Add(System.Object)"> + <summary> + Adds an object to the lifetime container. + </summary> + <param name="item">The item to be added to the lifetime container.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Contains(System.Object)"> + <summary> + Determine if a given object is in the lifetime container. + </summary> + <param name="item"> + The item to locate in the lifetime container. + </param> + <returns> + Returns true if the object is contained in the lifetime + container; returns false otherwise. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Remove(System.Object)"> + <summary> + Removes an item from the lifetime container. The item is + not disposed. + </summary> + <param name="item">The item to be removed.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Count"> + <summary> + Gets the number of references in the lifetime container + </summary> + <value> + The number of references in the lifetime container + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LifetimeContainer"> + <summary> + Represents a lifetime container. + </summary> + <remarks> + A lifetime container tracks the lifetime of an object, and implements + IDisposable. When the container is disposed, any objects in the + container which implement IDisposable are also disposed. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Add(System.Object)"> + <summary> + Adds an object to the lifetime container. + </summary> + <param name="item">The item to be added to the lifetime container.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Contains(System.Object)"> + <summary> + Determine if a given object is in the lifetime container. + </summary> + <param name="item"> + The item to locate in the lifetime container. + </param> + <returns> + Returns true if the object is contained in the lifetime + container; returns false otherwise. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Dispose"> + <summary> + Releases the resources used by the <see cref="T:Microsoft.Practices.ObjectBuilder2.LifetimeContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Dispose(System.Boolean)"> + <summary> + Releases the managed resources used by the DbDataReader and optionally releases the unmanaged resources. + </summary> + <param name="disposing"> + true to release managed and unmanaged resources; false to release only unmanaged resources. + </param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the lifetime container. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the life time container. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through the lifetime container. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the life time container. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Remove(System.Object)"> + <summary> + Removes an item from the lifetime container. The item is + not disposed. + </summary> + <param name="item">The item to be removed.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Count"> + <summary> + Gets the number of references in the lifetime container + </summary> + <value> + The number of references in the lifetime container + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"> + <summary> + A custom collection over <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Clear(System.Type,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <param name="policyInterface">The type of policy to remove.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.ClearAll"> + <summary> + Removes all policies from the list. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.ClearDefault(System.Type)"> + <summary> + Removes a default policy. + </summary> + <param name="policyInterface">The type the policy was registered as.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Get(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.GetNoDefault(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies to.</param> + <param name="localOnly">True if the search should be in the local policy list only; otherwise false to search up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Set(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <param name="policyInterface">The <see cref="T:System.Type"/> of the policy.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.SetDefault(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <param name="policyInterface">The interface to register the policy under.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PolicyList"> + <summary> + A custom collection wrapper over <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.#ctor"> + <summary> + Initialize a new instance of a <see cref="T:Microsoft.Practices.ObjectBuilder2.PolicyList"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.#ctor(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Initialize a new instance of a <see cref="T:Microsoft.Practices.ObjectBuilder2.PolicyList"/> class with another policy list. + </summary> + <param name="innerPolicyList">An inner policy list to search.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Clear(System.Type,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <param name="policyInterface">The type of policy to remove.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.ClearAll"> + <summary> + Removes all policies from the list. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.ClearDefault(System.Type)"> + <summary> + Removes a default policy. + </summary> + <param name="policyInterface">The type the policy was registered as.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Get(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.GetNoDefault(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies to.</param> + <param name="localOnly">True if the search should be in the local policy list only; otherwise false to search up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Set(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <param name="policyInterface">The <see cref="T:System.Type"/> of the policy.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.SetDefault(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <param name="policyInterface">The interface to register the policy under.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.PolicyList.Count"> + <summary> + Gets the number of items in the locator. + </summary> + <value> + The number of items in the locator. + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions"> + <summary> + Extension methods on <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to provide convenience + overloads (generic versions, mostly). + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Clear``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <typeparam name="TPolicyInterface">The type the policy was registered as.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to remove the policy from.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.ClearDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Removes a default policy. + </summary> + <typeparam name="TPolicyInterface">The type the policy was registered as.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to remove the policy from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,System.Boolean)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean)"> + <summary> + Get the non default policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,System.Boolean)"> + <summary> + Get the non default policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Set``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,``0,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add the policy to.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.SetDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,``0)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <typeparam name="TPolicyInterface">The interface to register the policy under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add the policy to.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.RecoveryStack"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRecoveryStack"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.RecoveryStack.Add(Microsoft.Practices.ObjectBuilder2.IRequiresRecovery)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> object to this + list. + </summary> + <param name="recovery">Object to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.RecoveryStack.ExecuteRecovery"> + <summary> + Execute the <see cref="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"/> method + of everything in the recovery list. Recoveries will execute + in the opposite order of add - it's a stack. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.RecoveryStack.Count"> + <summary> + Return the number of recovery objects currently in the stack. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"> + <summary> + Implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/> which will notify an object about + the completion of a BuildUp operation, or start of a TearDown operation. + </summary> + <remarks> + This strategy checks the object that is passing through the builder chain to see if it + implements IBuilderAware and if it does, it will call <see cref="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnBuiltUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"/> + and <see cref="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnTearingDown"/>. This strategy is meant to be used from the + <see cref="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PostInitialization"/> stage. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderAware"> + <summary> + Implemented on a class when it wants to receive notifications + about the build process. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnBuiltUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Called by the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"/> when the object is being built up. + </summary> + <param name="buildKey">The key of the object that was just built up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnTearingDown"> + <summary> + Called by the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"/> when the object is being torn down. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderStage"> + <summary> + Enumeration to represent the object builder stages. + </summary> + <remarks> + The order of the values in the enumeration is the order in which the stages are run. + </remarks> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PreCreation"> + <summary> + Strategies in this stage run before creation. Typical work done in this stage might + include strategies that use reflection to set policies into the context that other + strategies would later use. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.Creation"> + <summary> + Strategies in this stage create objects. Typically you will only have a single policy-driven + creation strategy in this stage. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.Initialization"> + <summary> + Strategies in this stage work on created objects. Typical work done in this stage might + include setter injection and method calls. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PostInitialization"> + <summary> + Strategies in this stage work on objects that are already initialized. Typical work done in + this stage might include looking to see if the object implements some notification interface + to discover when its initialization stage has been completed. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy"> + <summary> + Represents a builder policy for mapping build keys. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"> + <summary> + Represents a builder policy for mapping build keys. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping. This parameter can be null + (called when getting container registrations).</param> + <returns>The new build key.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy"/> with the new build key. + </summary> + <param name="newBuildKey">The new build key.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping, unused in this implementation.</param> + <returns>The new build key.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingStrategy"> + <summary> + Represents a strategy for mapping build keys in the build up operation. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. Looks for the <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"/> + and if found maps the build key for the current operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"/> that can map + generic types. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy"/> instance + that will map generic types. + </summary> + <param name="destinationKey">Build key to map to. This must be or contain an open generic type.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping.</param> + <returns>The new build key.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildOperation"> + <summary> + Base class for the current operation stored in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildOperation.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.BuildOperation"/>. + </summary> + <param name="typeBeingConstructed">Type currently being built.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuildOperation.TypeBeingConstructed"> + <summary> + The type that's currently being built. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildPlanStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that will look for a build plan + in the current context. If it exists, it invokes it, otherwise + it creates one and stores it for later, and invokes it. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildPlanStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that chooses + constructors based on these criteria: first, pick a constructor marked with the + <typeparamref name="TInjectionConstructorMarkerAttribute"/> attribute. If there + isn't one, then choose the constructor with the longest parameter list. If that is ambiguous, + then throw. + </summary> + <exception cref="T:System.InvalidOperationException">Thrown when the constructor to choose is ambiguous.</exception> + <typeparam name="TInjectionConstructorMarkerAttribute">Attribute used to mark the constructor to call.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicy`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedConstructor"> + <summary> + Objects of this type are the return value from <see cref="M:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + It encapsulates the desired <see cref="T:System.Reflection.ConstructorInfo"/> with the string keys + needed to look up the <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for each + parameter. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1"> + <summary> + Base class for return values from selector policies that + return a memberinfo of some sort plus a list of parameter + keys to look up the parameter resolvers. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters"> + <summary> + Base class for return of selector policies that need + to keep track of a set of parameter keys. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters.AddParameterKey(System.String)"> + <summary> + Add a new parameter key to this object. Keys are assumed + to be in the order of the parameters to the constructor. + </summary> + <param name="newKey">Key for the next parameter to look up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters.GetParameterKeys"> + <summary> + The set of keys for the constructor parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1.#ctor(`0)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1"/>, storing + the given member info. + </summary> + <param name="memberInfo">Member info to store.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1.MemberInfo"> + <summary> + The member info stored. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedConstructor.#ctor(System.Reflection.ConstructorInfo)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedConstructor"/> instance which + contains the given constructor. + </summary> + <param name="constructor">The constructor to wrap.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedConstructor.Constructor"> + <summary> + The constructor this object wraps. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"> + <summary> + This class records the information about which constructor argument is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.#ctor(System.Type,System.String,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"/> class. + </summary> + <param name="typeBeingConstructed">The type that is being constructed.</param> + <param name="constructorSignature">A string representing the constructor being called.</param> + <param name="parameterName">Parameter being resolved.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ToString"> + <summary> + Generate the string describing what parameter was being resolved. + </summary> + <returns>The description string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ConstructorSignature"> + <summary> + String describing the constructor being set up. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ParameterName"> + <summary> + Parameter that's being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation"> + <summary> + A class that records that a constructor is about to be call, and is + responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.ToString"> + <summary> + Generate the description string. + </summary> + <returns>The string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.ConstructorSignature"> + <summary> + Constructor we're trying to call. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation"> + <summary> + A class that records that a constructor is about to be call, and is + responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.ToString"> + <summary> + Generate the description string. + </summary> + <returns>The string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.MethodSignature"> + <summary> + Method we're trying to call. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation"> + <summary> + This class records the information about which constructor argument is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.#ctor(System.Type,System.String,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"/> class. + </summary> + <param name="typeBeingConstructed">The type that is being constructed.</param> + <param name="methodSignature">A string representing the method being called.</param> + <param name="parameterName">Parameter being resolved.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.ToString"> + <summary> + Generate the string describing what parameter was being resolved. + </summary> + <returns>The description string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.MethodSignature"> + <summary> + String describing the method being set up. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.ParameterName"> + <summary> + Parameter that's being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertyOperation"> + <summary> + A base class that holds the information shared by all operations + performed by the container while setting properties. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:System.Object"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"> + <summary> + Generate the description of this operation. + </summary> + <returns>The string.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.PropertyOperation.PropertyName"> + <summary> + The property value currently being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation"> + <summary> + This class records the information about which property value is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:System.Object"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation"> + <summary> + This class records the information about which property value is currently + being set, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation"/> class. + </summary> + <param name="typeBeingConstructed">Type property is on.</param> + <param name="propertyName">Name of property being set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DeferredResolveBuildPlanPolicy"> + <summary> + Build plan for <see cref="T:System.Func`1"/> that will + return a func that will resolve the requested type + through this container later. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FactoryDelegateBuildPlanPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> that selects + methods by looking for the given <typeparamref name="TMarkerAttribute"/> + attribute on those methods. + </summary> + <typeparam name="TMarkerAttribute">Type of attribute used to mark methods + to inject.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicy`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMethod"> + <summary> + Objects of this type are the return value from <see cref="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + It encapsulates the desired <see cref="T:System.Reflection.MethodInfo"/> with the string keys + needed to look up the <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for each + parameter. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMethod.#ctor(System.Reflection.MethodInfo)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedMethod"/> instance which + contains the given method. + </summary> + <param name="method">The method</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedMethod.Method"> + <summary> + The constructor this object wraps. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.OverriddenBuildPlanMarkerPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertySelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> that looks + for properties marked with the <typeparamref name="TResolutionAttribute"/> + attribute that are also settable and not indexers. + </summary> + <typeparam name="TResolutionAttribute"></typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorPolicy`1.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedProperty"> + <summary> + Objects of this type are returned from + <see cref="M:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + This class combines the <see cref="T:System.Reflection.PropertyInfo"/> about + the property with the string key used to look up the resolver + for this property's value. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedProperty.#ctor(System.Reflection.PropertyInfo,System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedProperty"/> + with the given <see cref="T:System.Reflection.PropertyInfo"/> and key. + </summary> + <param name="property">The property.</param> + <param name="key">Key to use to look up the resolver.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedProperty.Property"> + <summary> + PropertyInfo for this property. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedProperty.Key"> + <summary> + Key to look up this property's resolver. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy"> + <summary> + Implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"/>. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"> + <summary> + A builder policy that lets you keep track of the current + resolvers and will remove them from the given policy set. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy.AddResolverKey(System.Object)"> + <summary> + Add a new resolver to track by key. + </summary> + <param name="key">Key that was used to add the resolver to the policy set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Remove the currently tracked resolvers from the given policy list. + </summary> + <param name="policies">Policy list to remove the resolvers from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.AddResolverKey(System.Object)"> + <summary> + Add a new resolver to track by key. + </summary> + <param name="key">Key that was used to add the resolver to the policy set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Remove the currently tracked resolvers from the given policy list. + </summary> + <param name="policies">Policy list to remove the resolvers from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.GetTracker(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Get an instance that implements <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"/>, + either the current one in the policy set or creating a new one if it doesn't + exist. + </summary> + <param name="policies">Policy list to look up from.</param> + <param name="buildKey">Build key to track.</param> + <returns>The resolver tracker.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.TrackKey(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Object)"> + <summary> + Add a key to be tracked to the current tracker. + </summary> + <param name="policies">Policy list containing the resolvers and trackers.</param> + <param name="buildKey">Build key for the resolvers being tracked.</param> + <param name="resolverKey">Key for the resolver.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Remove the resolvers for the given build key. + </summary> + <param name="policies">Policy list containing the build key.</param> + <param name="buildKey">Build key.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + calls back into the build chain to build up the dependency, passing + a type given at compile time as its build key. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy.#ctor(System.Type)"> + <summary> + Create a new instance storing the given type. + </summary> + <param name="typeToBuild">Type to resolve.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain"> + <summary> + This interface defines a standard method to convert any + <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> regardless + of the stage enum into a regular, flat strategy chain. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain.MakeStrategyChain"> + <summary> + Convert this <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> into + a flat <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>. + </summary> + <returns>The flattened <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"> + <summary> + Represents a chain of responsibility for builder strategies. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.Reverse"> + <summary> + Reverse the order of the strategy chain. + </summary> + <returns>The reversed strategy chain.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.ExecuteBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the Buildup methods on the strategies. + </summary> + <param name="context">Context for the build process.</param> + <returns>The build up object</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.ExecuteTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the TearDown methods on the strategies. + </summary> + <param name="context">Context for the teardown process.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/> implementation that uses + a <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/> to figure out if an object + has already been created and to update or remove that + object from some backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"> + <summary> + Represents a chain of responsibility for builder strategies partitioned by stages. + </summary> + <typeparam name="TStageEnum">The stage enumeration to partition the strategies.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.#ctor"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.#ctor(Microsoft.Practices.ObjectBuilder2.StagedStrategyChain{`0})"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> class with an inner strategy chain to use when building. + </summary> + <param name="innerChain">The inner strategy chain to use first when finding strategies in the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.Add(Microsoft.Practices.ObjectBuilder2.IBuilderStrategy,`0)"> + <summary> + Adds a strategy to the chain at a particular stage. + </summary> + <param name="strategy">The strategy to add to the chain.</param> + <param name="stage">The stage to add the strategy.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.AddNew``1(`0)"> + <summary> + Add a new strategy for the <paramref name="stage"/>. + </summary> + <typeparam name="TStrategy">The <see cref="T:System.Type"/> of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/></typeparam> + <param name="stage">The stage to add the strategy.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.Clear"> + <summary> + Clear the current strategy chain list. + </summary> + <remarks> + This will not clear the inner strategy chain if this instane was created with one. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.MakeStrategyChain"> + <summary> + Makes a strategy chain based on this instance. + </summary> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/>.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"> + <summary> + Represents a chain of responsibility for builder strategies. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.#ctor"> + <summary> + Initialzie a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.#ctor(System.Collections.IEnumerable)"> + <summary> + Initialzie a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/> class with a colleciton of strategies. + </summary> + <param name="strategies">A collection of strategies to initialize the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.Add(Microsoft.Practices.ObjectBuilder2.IBuilderStrategy)"> + <summary> + Adds a strategy to the chain. + </summary> + <param name="strategy">The strategy to add to the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.AddRange(System.Collections.IEnumerable)"> + <summary> + Adds strategies to the chain. + </summary> + <param name="strategyEnumerable">The strategies to add to the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.Reverse"> + <summary> + Reverse the order of the strategy chain. + </summary> + <returns>The reversed strategy chain.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context to build up. + </summary> + <param name="context">Context for the build processes.</param> + <returns>The build up object</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the TearDown methods on the strategies. + </summary> + <param name="context">Context for the teardown process.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.System#Collections#Generic#IEnumerable{Microsoft#Practices#ObjectBuilder2#IBuilderStrategy}#GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + + <returns> + An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions"> + <summary> + The almost inevitable collection of extra helper methods on + <see cref="T:System.Collections.Generic.IEnumerable`1"/> to augment the rich set of what + Linq already gives us. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})"> + <summary> + Execute the provided <paramref name="action"/> on every item in <paramref name="sequence"/>. + </summary> + <typeparam name="TItem">Type of the items stored in <paramref name="sequence"/></typeparam> + <param name="sequence">Sequence of items to process.</param> + <param name="action">Code to run over each item.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.JoinStrings``1(System.Collections.Generic.IEnumerable{``0},System.String,System.Func{``0,System.String})"> + <summary> + Create a single string from a sequenc of items, separated by the provided <paramref name="separator"/>, + and with the conversion to string done by the given <paramref name="converter"/>. + </summary> + <remarks>This method does basically the same thing as <see cref="M:System.String.Join(System.String,System.String[])"/>, + but will work on any sequence of items, not just arrays.</remarks> + <typeparam name="TItem">Type of items in the sequence.</typeparam> + <param name="sequence">Sequence of items to convert.</param> + <param name="separator">Separator to place between the items in the string.</param> + <param name="converter">The conversion function to change TItem -> string.</param> + <returns>The resulting string.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.JoinStrings``1(System.Collections.Generic.IEnumerable{``0},System.String)"> + <summary> + Create a single string from a sequenc of items, separated by the provided <paramref name="separator"/>, + and with the conversion to string done by the item's <see cref="M:System.Object.ToString"/> method. + </summary> + <remarks>This method does basically the same thing as <see cref="M:System.String.Join(System.String,System.String[])"/>, + but will work on any sequence of items, not just arrays.</remarks> + <typeparam name="TItem">Type of items in the sequence.</typeparam> + <param name="sequence">Sequence of items to convert.</param> + <param name="separator">Separator to place between the items in the string.</param> + <returns>The resulting string.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"> + <summary> + Build key used to combine a type object with a string name. Used by + ObjectBuilder to indicate exactly what is being built. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.#ctor(System.Type,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance with the given + type and name. + </summary> + <param name="type"><see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> to build.</param> + <param name="name">Key to use to look up type mappings and singletons.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance for the default + buildup of the given type. + </summary> + <param name="type"><see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> to build.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Make``1"> + <summary> + This helper method creates a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance. It is + initialized for the default key for the given type. + </summary> + <typeparam name="T">Type to build.</typeparam> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Make``1(System.String)"> + <summary> + This helper method creates a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance for + the given type and key. + </summary> + <typeparam name="T">Type to build</typeparam> + <param name="name">Key to use to look up type mappings and singletons.</param> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance initialized with the given type and name.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Equals(System.Object)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type. Also, comparing + against a different type will also return false.</remarks> + <param name="obj">Object to compare to.</param> + <returns>True if the two keys are equal, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.GetHashCode"> + <summary> + Calculate a hash code for this instance. + </summary> + <returns>A hash code.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.op_Equality(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances for equality. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type.</remarks> + <param name="left">First of the two keys to compare.</param> + <param name="right">Second of the two keys to compare.</param> + <returns>True if the values of the keys are the same, else false.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.op_Inequality(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances for inequality. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type. If either field differs + the keys are not equal.</remarks> + <param name="left">First of the two keys to compare.</param> + <param name="right">Second of the two keys to compare.</param> + <returns>false if the values of the keys are the same, else true.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.ToString"> + <summary> + Formats the build key as a string (primarily for debugging). + </summary> + <returns>A readable string representation of the build key.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"> + <summary> + Return the <see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> stored in this build key. + </summary> + <value>The type to build.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Name"> + <summary> + Returns the name stored in this build key. + </summary> + <remarks>The name to use when building.</remarks> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> so that + you can new up a key using generic syntax. + </summary> + <typeparam name="T">Type for the key.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"/> that + specifies the given type. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"/> that + specifies the given type and name. + </summary> + <param name="name">Name for the key.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.Sequence"> + <summary> + A series of helper methods to deal with sequences - + objects that implement <see cref="T:System.Collections.Generic.IEnumerable`1"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.Sequence.Collect``1(``0[])"> + <summary> + A function that turns an arbitrary parameter list into an + <see cref="T:System.Collections.Generic.IEnumerable`1"/>. + </summary> + <typeparam name="T">Type of arguments.</typeparam> + <param name="arguments">The items to put into the collection.</param> + <returns>An array that contains the values of the <paramref name="arguments"/>.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.Sequence.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})"> + <summary> + Given two sequences, return a new sequence containing the corresponding values + from each one. + </summary> + <typeparam name="TFirstSequenceElement">Type of first sequence.</typeparam> + <typeparam name="TSecondSequenceElement">Type of second sequence.</typeparam> + <param name="sequence1">First sequence of items.</param> + <param name="sequence2">Second sequence of items.</param> + <returns>New sequence of pairs. This sequence ends when the shorter of sequence1 and sequence2 does.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ParameterOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> class that lets you + override a named parameter passed to a constructor. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverride.#ctor(System.String,System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ParameterOverride"/> object that will + override the given named constructor parameter, and pass the given + value. + </summary> + <param name="parameterName">Name of the constructor parameter.</param> + <param name="parameterValue">Value to pass for the constructor.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ParameterOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.ParameterOverride"/> that lets you + specify multiple parameter overrides in one shot rather than having + to construct multiple objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverrides.MakeOverride(System.String,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.PropertyOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that lets you override + the value for a specified property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverride.#ctor(System.String,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.PropertyOverride"/>. + </summary> + <param name="propertyName">The property name.</param> + <param name="propertyValue">Value to use for the property.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.PropertyOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.PropertyOverride"/> that lets you + specify multiple property overrides in one shot rather than having + to construct multiple objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverrides.MakeOverride(System.String,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolutionFailedException"> + <summary> + The exception thrown by the Unity container when + an attempt to resolve a dependency fails. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolutionFailedException.#ctor(System.Type,System.String,System.Exception,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolutionFailedException"/> that records + the exception for the given type and name. + </summary> + <param name="typeRequested">Type requested from the container.</param> + <param name="nameRequested">Name requested from the container.</param> + <param name="innerException">The actual exception that caused the failure of the build.</param> + <param name="context">The build context representing the failed operation.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ResolutionFailedException.TypeRequested"> + <summary> + The type that was being requested from the container at the time of failure. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ResolutionFailedException.NameRequested"> + <summary> + The name that was being requested from the container at the time of failure. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration"> + <summary> + Interface defining the configuration interface exposed by the + Static Factory extension. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration.RegisterFactory``1(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration.RegisterFactory``1(System.String,System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/> and <paramref name="name"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="name">The name that will be used when requesting to resolve this type.</param> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> that lets you register a + delegate with the container to create an object, rather than calling + the object's constructor. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.Initialize"> + <summary> + Initialize this extension. This particular extension requires no + initialization work. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.RegisterFactory``1(System.String,System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/> and <paramref name="name"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="name">The name that will be used when requesting to resolve this type.</param> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.RegisterFactory``1(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.TypeBasedOverride"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that + acts as a decorator over another <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>. + This checks to see if the current type being built is the + right one before checking the inner <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride.#ctor(System.Type,Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride"/> + </summary> + <param name="targetType">Type to check for.</param> + <param name="innerOverride">Inner override to check after type matches.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.TypeBasedOverride`1"> + <summary> + A convenience version of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride"/> that lets you + specify the type to construct via generics syntax. + </summary> + <typeparam name="T">Type to check for.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride`1.#ctor(Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride`1"/>. + </summary> + <param name="innerOverride">Inner override to check after type matches.</param> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainer"> + <summary> + A simple, extensible dependency injection container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.#ctor"> + <summary> + Create a default <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.#ctor(Microsoft.Practices.Unity.UnityContainer)"> + <summary> + Create a <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> with the given parent container. + </summary> + <param name="parent">The parent <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. The current object + will apply its own settings first, and then check the parent for additional ones.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + RegisterType a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + RegisterType an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <param name="lifetime"> + <para>If true, the container will take over the lifetime of the instance, + calling Dispose on it (if it's <see cref="T:System.IDisposable"/>) when the container is Disposed.</para> + <para> + If false, container will not maintain a strong reference to <paramref name="instance"/>. User is reponsible + for disposing instance, and for keeping the instance from being garbage collected.</para></param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Get an instance of the requested type with the given name from the container. + </summary> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="resolverOverrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <param name="t">The type requested.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <paramref name="t"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.BuildUp(System.Type,System.Object,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Teardown(System.Object)"> + <summary> + Run an existing object through the container, and clean it up. + </summary> + <param name="o">The object to tear down.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.AddExtension(Microsoft.Practices.Unity.UnityContainerExtension)"> + <summary> + Add an extension object to the container. + </summary> + <param name="extension"><see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Configure(System.Type)"> + <summary> + Get access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <param name="configurationInterface"><see cref="T:System.Type"/> of configuration interface required.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RemoveAllExtensions"> + <summary> + Remove all installed extensions from this container. + </summary> + <remarks> + <para> + This method removes all extensions from the container, including the default ones + that implement the out-of-the-box behavior. After this method, if you want to use + the container again you will need to either readd the default extensions or replace + them with your own. + </para> + <para> + The registered instances and singletons that have already been set up in this container + do not get removed. + </para> + </remarks> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.CreateChildContainer"> + <summary> + Create a child container. + </summary> + <remarks> + A child container shares the parent's configuration, but can be configured with different + settings or lifetime.</remarks> + <returns>The new child container.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Dispose"> + <summary> + Dispose this container instance. + </summary> + <remarks> + Disposing the container also disposes any child containers, + and disposes any instances whose lifetimes are managed + by the container. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Dispose(System.Boolean)"> + <summary> + Dispose this container instance. + </summary> + <remarks> + This class doesn't have a finalizer, so <paramref name="disposing"/> will always be true.</remarks> + <param name="disposing">True if being called from the IDisposable.Dispose + method, false if being called from a finalizer.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.ClearExistingBuildPlan(System.Type,System.String)"> + <summary> + Remove policies associated with building this type. This removes the + compiled build plan so that it can be rebuilt with the new settings + the next time this type is resolved. + </summary> + <param name="typeToInject">Type of object to clear the plan for.</param> + <param name="name">Name the object is being registered with.</param> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainer.Parent"> + <summary> + The parent of this container. + </summary> + <value>The parent container, or null if this container doesn't have one.</value> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainer.Registrations"> + <summary> + Get a sequence of <see cref="T:Microsoft.Practices.Unity.ContainerRegistration"/> that describe the current state + of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainer.ExtensionContextImpl"> + <summary> + Implementation of the ExtensionContext that is actually used + by the UnityContainer implementation. + </summary> + <remarks> + This is a nested class so that it can access state in the + container that would otherwise be inaccessible. + </remarks> + </member> + <member name="E:Microsoft.Practices.Unity.UnityContainer.ExtensionContextImpl.RegisteringInstance"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.UnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerExtensions"> + <summary> + Extension class that adds a set of convenience overloads to the + <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> interface. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type with specific members to be injected. + </summary> + <typeparam name="T">Type this registration is for.</typeparam> + <param name="container">Container to configure.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + <para> + This method is used to tell the container that when asked for type <typeparamref name="TFrom"/>, + actually return an instance of type <typeparamref name="TTo"/>. This is very useful for + getting instances of interfaces. + </para> + <para> + This overload registers a default mapping and transient lifetime. + </para> + </remarks> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + This method is used to tell the container that when asked for type <typeparamref name="TFrom"/>, + actually return an instance of type <typeparamref name="TTo"/>. This is very useful for + getting instances of interfaces. + </remarks> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name of this mapping.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to apply the <paramref name="lifetimeManager"/> to.</typeparam> + <param name="container">Container to configure.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to configure injection on.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name that will be used to request the type.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to apply the <paramref name="lifetimeManager"/> to.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name that will be used to request the type.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type with specific members to be injected. + </summary> + <param name="container">Container to configure.</param> + <param name="t">Type this registration is for.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + <para> + This method is used to tell the container that when asked for type <paramref name="from"/>, + actually return an instance of type <paramref name="to"/>. This is very useful for + getting instances of interfaces. + </para> + <para> + This overload registers a default mapping. + </para> + </remarks> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + This method is used to tell the container that when asked for type <paramref name="from"/>, + actually return an instance of type <paramref name="to"/>. This is very useful for + getting instances of interfaces. + </remarks> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to apply the <paramref name="lifetimeManager"/> to.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to configure in the container.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to apply the <paramref name="lifetimeManager"/> to.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,``0)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration and has the container take over the lifetime of the instance.</para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="container">Container to configure.</param> + <param name="instance">Object to returned.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,``0,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration (name = null). + </para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="container">Container to configure.</param> + <param name="instance">Object to returned.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,System.String,``0)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload automatically has the container take ownership of the <paramref name="instance"/>.</para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="instance">Object to returned.</param> + <param name="container">Container to configure.</param> + <param name="name">Name for registration.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,System.String,``0,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="instance">Object to returned.</param> + <param name="container">Container to configure.</param> + <param name="name">Name for registration.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration and has the container take over the lifetime of the instance.</para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration (name = null). + </para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,System.Object)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload automatically has the container take ownership of the <paramref name="instance"/>.</para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the default requested type from the container. + </summary> + <typeparam name="T"><see cref="T:System.Type"/> of object to get from the container.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the requested type with the given name from the container. + </summary> + <typeparam name="T"><see cref="T:System.Type"/> of object to get from the container.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the default requested type from the container. + </summary> + <param name="container">Container to resolve from.</param> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.ResolveAll``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <typeparam name="T">The type requested.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <typeparamref name="T"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp``1(Microsoft.Practices.Unity.IUnityContainer,``0,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para> + <para> + This overload uses the default registrations. + </para> + </remarks> + <typeparam name="T"><see cref="T:System.Type"/> of object to perform injection on.</typeparam> + <param name="container">Container to resolve through.</param> + <param name="existing">Instance to build up.</param> + <param name="resolverOverrides">Any overrides for the buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <typeparamref name="T"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp``1(Microsoft.Practices.Unity.IUnityContainer,``0,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <typeparam name="T"><see cref="T:System.Type"/> of object to perform injection on.</typeparam> + <param name="container">Conatiner to resolve through.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the Buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <typeparamref name="T"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para> + <para> + This overload uses the default registrations. + </para> + </remarks> + <param name="container">Container to resolve through.</param> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="resolverOverrides">Any overrides for the Buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.AddNewExtension``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Creates a new extension object and adds it to the container. + </summary> + <typeparam name="TExtension">Type of <see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add. The extension type + will be resolved from within the supplied <paramref name="container"/>.</typeparam> + <param name="container">Container to add the extension to.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Configure``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Resolve access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <typeparam name="TConfigurator">The configuration interface required.</typeparam> + <param name="container">Container to configure.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Check if a particular type has been registered with the container with + the default name. + </summary> + <param name="container">Container to inspect.</param> + <param name="typeToCheck">Type to check registration for.</param> + <returns>True if this type has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String)"> + <summary> + Check if a particular type/name pair has been registered with the container. + </summary> + <param name="container">Container to inspect.</param> + <param name="typeToCheck">Type to check registration for.</param> + <param name="nameToCheck">Name to check registration for.</param> + <returns>True if this type/name pair has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Check if a particular type has been registered with the container with the default name. + </summary> + <typeparam name="T">Type to check registration for.</typeparam> + <param name="container">Container to inspect.</param> + <returns>True if this type has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered``1(Microsoft.Practices.Unity.IUnityContainer,System.String)"> + <summary> + Check if a particular type/name pair has been registered with the container. + </summary> + <typeparam name="T">Type to check registration for.</typeparam> + <param name="container">Container to inspect.</param> + <param name="nameToCheck">Name to check registration for.</param> + <returns>True if this type/name pair has been registered, false if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension"> + <summary> + This extension supplies the default behavior of the UnityContainer API + by handling the context events and setting policies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension.Initialize"> + <summary> + Install the default container behavior into the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension.Remove"> + <summary> + Remove the default behavior from the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityDefaultStrategiesExtension"> + <summary> + This extension installs the default strategies and policies into the container + to implement the standard behavior of the Unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultStrategiesExtension.Initialize"> + <summary> + Add the default ObjectBuilder strategies & policies to the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Guard"> + <summary> + A static helper class that includes various parameter checking routines. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(System.Object,System.String)"> + <summary> + Throws <see cref="T:System.ArgumentNullException"/> if the given argument is null. + </summary> + <exception cref="T:System.ArgumentNullException"> if tested value if null.</exception> + <param name="argumentValue">Argument value to test.</param> + <param name="argumentName">Name of the argument being tested.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNullOrEmpty(System.String,System.String)"> + <summary> + Throws an exception if the tested string argument is null or the empty string. + </summary> + <exception cref="T:System.ArgumentNullException">Thrown if string value is null.</exception> + <exception cref="T:System.ArgumentException">Thrown if the string is empty</exception> + <param name="argumentValue">Argument value to check.</param> + <param name="argumentName">Name of argument being checked.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.TypeIsAssignable(System.Type,System.Type,System.String)"> + <summary> + Verifies that an argument type is assignable from the provided type (meaning + interfaces are implemented, or classes exist in the base class hierarchy). + </summary> + <param name="assignmentTargetType">The argument type that will be assigned to.</param> + <param name="assignmentValueType">The type of the value being assigned.</param> + <param name="argumentName">Argument name.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.InstanceIsAssignable(System.Type,System.Object,System.String)"> + <summary> + Verifies that an argument instance is assignable from the provided type (meaning + interfaces are implemented, or classes exist in the base class hierarchy, or instance can be + assigned through a runtime wrapper, as is the case for COM Objects). + </summary> + <param name="assignmentTargetType">The argument type that will be assigned to.</param> + <param name="assignmentInstance">The instance that will be assigned.</param> + <param name="argumentName">Argument name.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.MethodReflectionHelper"> + <summary> + Helper class to wrap common reflection stuff dealing with + methods. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.#ctor(System.Reflection.MethodBase)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.MethodReflectionHelper"/> instance that + lets us do more reflection stuff on that method. + </summary> + <param name="method">The method to reflect on.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.GetClosedParameterTypes(System.Type[])"> + <summary> + Given our set of generic type arguments, + </summary> + <param name="genericTypeArguments">The generic type arguments.</param> + <returns>An array with closed parameter types. </returns> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.MethodHasOpenGenericParameters"> + <summary> + Returns true if any of the parameters of this method + are open generics. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.ParameterTypes"> + <summary> + Return the <see cref="T:System.Type"/> of each parameter for this + method. + </summary> + <returns>Sequence of <see cref="T:System.Type"/> objects, one for + each parameter in order.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Pair`2"> + <summary> + A helper class that encapsulates two different + data items together into a a single item. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Pair`2.#ctor(`0,`1)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.Pair`2"/> containing + the two values give. + </summary> + <param name="first">First value</param> + <param name="second">Second value</param> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.Pair`2.First"> + <summary> + The first value of the pair. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.Pair`2.Second"> + <summary> + The second value of the pair. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Pair"> + <summary> + Container for a Pair helper method. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Pair.Make``2(``0,``1)"> + <summary> + A helper factory method that lets users take advantage of type inference. + </summary> + <typeparam name="TFirstParameter">Type of first value.</typeparam> + <typeparam name="TSecondParameter">Type of second value.</typeparam> + <param name="first">First value.</param> + <param name="second">Second value.</param> + <returns>A new <see cref="T:Microsoft.Practices.Unity.Utility.Pair`2"/> instance.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ParameterMatcher"> + <summary> + A utility class that handles the logic of matching parameter + lists, so we can find the right constructor and method overloads. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.#ctor(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue})"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.ParameterMatcher"/> that will attempt to + match the given parameter types. + </summary> + <param name="parametersToMatch">Target parameters to match against.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.Matches(System.Collections.Generic.IEnumerable{System.Type})"> + <summary> + Tests to see if the given set of types matches the ones + we're looking for. + </summary> + <param name="candidate">parameter list to look for.</param> + <returns>true if they match, false if they don't.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.Matches(System.Collections.Generic.IEnumerable{System.Reflection.ParameterInfo})"> + <summary> + Tests to see if the given set of types matches the ones we're looking for. + </summary> + <param name="candidate">Candidate method signature to look for.</param> + <returns>True if they match, false if they don't.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper"> + <summary> + Another reflection helper class that has extra methods + for dealing with ParameterInfos. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ReflectionHelper"> + <summary> + A small helper class to encapsulate details of the + reflection API, particularly around generics. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.ReflectionHelper"/> instance that + lets you look at information about the given type. + </summary> + <param name="typeToReflect">Type to do reflection on.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.MethodHasOpenGenericParameters(System.Reflection.MethodBase)"> + <summary> + Test the given <see cref="T:System.Reflection.MethodBase"/> object, looking at + the parameters. Determine if any of the parameters are + open generic types that need type attributes filled in. + </summary> + <param name="method">The method to check.</param> + <returns>True if any of the parameters are open generics. False if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.GetClosedParameterType(System.Type[])"> + <summary> + If this type is an open generic, use the + given <paramref name="genericArguments"/> array to + determine what the required closed type is and return that. + </summary> + <remarks>If the parameter is not an open type, just + return this parameter's type.</remarks> + <param name="genericArguments">Type arguments to substitute in for + the open type parameters.</param> + <returns>Corresponding closed type of this parameter.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.GetNamedGenericParameter(System.String)"> + <summary> + Given a generic argument name, return the corresponding type for this + closed type. For example, if the current type is SomeType<User>, and the + corresponding definition was SomeType<TSomething>, calling this method + and passing "TSomething" will return typeof(User). + </summary> + <param name="parameterName">Name of the generic parameter.</param> + <returns>Type of the corresponding generic parameter, or null if there + is no matching name.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"> + <summary> + The <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/> object we're reflecting over. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsGenericType"> + <summary> + Is this type generic? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsOpenGeneric"> + <summary> + Is this type an open generic (no type parameter specified) + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsArray"> + <summary> + Is this type an array type? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsGenericArray"> + <summary> + Is this type an array of generic elements? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.ArrayElementType"> + <summary> + The type of the elements in this type (if it's an array). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.InstanceConstructors"> + <summary> + Returns all the public constructors defined for the current reflected <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/>. + </summary> + <value> + An enumeration of <see cref="T:System.Reflection.ConstructorInfo"/> ConstructorInfo objects representing all the public instance constructors defined for the + current reflected <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/>, but not including the type initializer (static constructor). + </value> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper.#ctor(System.Reflection.ParameterInfo)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper"/> that + lets you query information about the given ParameterInfo object. + </summary> + <param name="parameter">Parameter to query.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.StaticReflection"> + <summary> + A set of helper methods to pick through lambdas and pull out + <see cref="T:System.Reflection.MethodInfo"/> from them. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMethodInfo(System.Linq.Expressions.Expression{System.Action})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object from an expression of the form + () => SomeClass.SomeMethod() + </summary> + <param name="expression">Expression describing the method to call.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMethodInfo``1(System.Linq.Expressions.Expression{System.Action{``0}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object from an expression of the form + x => x.SomeMethod() + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <param name="expression">Expression describing the method to call.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetPropertyGetMethodInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object for the get method from an expression of the form + x => x.SomeProperty + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <typeparam name="TProperty">The type for the property.</typeparam> + <param name="expression">Expression describing the property for which the get method is to be extracted.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetPropertySetMethodInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object for the set method from an expression of the form + x => x.SomeProperty + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <typeparam name="TProperty">The type for the property.</typeparam> + <param name="expression">Expression describing the property for which the set method is to be extracted.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMemberInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + + </summary> + <typeparam name="T"></typeparam> + <typeparam name="TProperty"></typeparam> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetConstructorInfo``1(System.Linq.Expressions.Expression{System.Func{``0}})"> + <summary> + Pull out a <see cref="T:System.Reflection.ConstructorInfo"/> object from an expression of the form () => new SomeType() + </summary> + <typeparam name="T">The type where the constructor is defined.</typeparam> + <param name="expression">Expression invoking the desired constructor.</param> + <returns>Corresponding <see cref="T:System.Reflection.ConstructorInfo"/>.</returns> + </member> + </members> +</doc>
Binary file src/packages/Unity.3.0.1304.1/lib/wp8/Microsoft.Practices.Unity.WindowsPhone.dll has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Unity.3.0.1304.1/lib/wp8/Microsoft.Practices.Unity.WindowsPhone.xml Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,6060 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>Microsoft.Practices.Unity.WindowsPhone</name> + </assembly> + <members> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that emits IL to call constructors + as part of creating a build plan. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"> + <summary> + Represents a strategy in the chain of responsibility. + Strategies are required to support both BuildUp and TearDown. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"> + <summary> + Represents a strategy in the chain of responsibility. + Strategies are required to support both BuildUp and TearDown. Although you + can implement this interface directly, you may also choose to use + <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> as the base class for your strategies, as + this class provides useful helper methods and makes support BuildUp and TearDown + optional. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy.PostTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PostTearDown method is called when the chain has finished the PreTearDown + phase and executes in reverse order from the PreTearDown calls. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderStrategy.PostTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PostTearDown method is called when the chain has finished the PreTearDown + phase and executes in reverse order from the PreTearDown calls. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <remarks>Existing object is an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext"/>.</remarks> + <param name="context">The context for the operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetPerBuildSingleton(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to set up a PerResolveLifetimeManager lifetime manager + if the current object is such. + </summary> + <param name="context">Current build context.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.CreateSignatureString(System.Reflection.ConstructorInfo)"> + <summary> + Build up the string that will represent the constructor signature + in any exception message. + </summary> + <param name="constructor"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetCurrentOperationToResolvingParameter(System.String,System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.SetCurrentOperationToInvokingConstructor(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForAttemptingToConstructInterface(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to throw an exception if + no existing object is present, but the user is attempting to build + an interface (usually due to the lack of a type mapping). + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForNullExistingObject(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to throw an exception if + a dependency cannot be resolved. + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodConstructorStrategy.ThrowForNullExistingObjectWithInvalidConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.String)"> + <summary> + A helper method used by the generated IL to throw an exception if + a dependency cannot be resolved because of an invalid constructor. + </summary> + <param name="context">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> currently being + used for the build of this object.</param> + <param name="signature">The signature of the invalid constructor.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext"> + <summary> + + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.#ctor(System.Type)"> + <summary> + + </summary> + <param name="typeToBuild"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.AddToBuildPlan(System.Linq.Expressions.Expression)"> + <summary> + + </summary> + <param name="expression"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.CreateParameterExpression(System.String,System.Type,System.Linq.Expressions.Expression)"> + <summary> + + </summary> + <param name="parameterKey"></param> + <param name="parameterType"></param> + <param name="setOperationExpression"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type,System.String)"> + <summary> + Helper method used by generated IL to look up a dependency resolver based on the given key. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of the dependency being resolved.</param> + <param name="resolverKey">Key the resolver was stored under.</param> + <returns>The found dependency resolver.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.TypeToBuild"> + <summary> + The type that is to be built with the dynamic build plan. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanGenerationContext.ContextParameter"> + <summary> + The context parameter represeting the <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> used when the build plan is executed. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanMethod"> + <summary> + + </summary> + <param name="context"></param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan"> + <summary> + + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy"> + <summary> + A build plan is an object that, when invoked, will create a new object + or fill in a given existing one. It encapsulates all the information + gathered by the strategies to construct a particular object. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"> + <summary> + Represents a builder policy interface. Since there are no fixed requirements + for policies, it acts as a marker interface from which to derive all other + policy interfaces. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan.#ctor(Microsoft.Practices.ObjectBuilder2.DynamicBuildPlanMethod)"> + <summary> + + </summary> + <param name="buildMethod"></param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlan.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + + </summary> + <param name="context"></param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"/> implementation + that constructs a build plan via dynamic IL emission. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that can create and return an <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanPolicy"/> + for the given build key. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Create a build plan using the given context and build key. + </summary> + <param name="context">Current build context.</param> + <param name="buildKey">Current build key.</param> + <returns>The build plan.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy"/> that + uses the given strategy chain to construct the build plan. + </summary> + <param name="strategies">The strategy chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Construct a build plan. + </summary> + <param name="context">The current build context.</param> + <param name="buildKey">The current build key.</param> + <returns>The created build plan.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that generates IL to call + chosen methods (as specified by the current <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/>) + as part of object build up. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.SetCurrentOperationToResolvingParameter(System.String,System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodCallStrategy.SetCurrentOperationToInvokingMethod(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that generates IL to resolve properties + on an object being built. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.SetCurrentOperationToResolvingPropertyValue(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DynamicMethodPropertySetterStrategy.SetCurrentOperationToSettingProperty(System.String,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + A helper method used by the generated IL to store the current operation in the build context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LazyDynamicMethodBuildPlanCreatorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildPlanCreatorPolicy"/> implementation + that constructs a build plan for creating <see cref="T:System.Lazy`1"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LazyDynamicMethodBuildPlanCreatorPolicy.CreatePlan(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Creates a build plan using the given context and build key. + </summary> + <param name="context">Current build context.</param> + <param name="buildKey">Current build key.</param> + <returns> + The build plan. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.AllClasses"> + <summary> + Provides helper methods to retrieve classes from assemblies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Reflection.Assembly[])"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>. + </summary> + <param name="assemblies">The assemblies.</param> + <returns>All visible, non-abstract classes found in the assemblies.</returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks>All exceptions thrown while getting types from the assemblies are ignored, and the types that can be retrieved are returned.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Boolean,System.Reflection.Assembly[])"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>, and optionally skips errors. + </summary> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <param name="assemblies">The assemblies.</param> + <returns> + All visible, non-abstract classes. + </returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromAssemblies(System.Collections.Generic.IEnumerable{System.Reflection.Assembly},System.Boolean)"> + <summary> + Returns all visible, non-abstract classes from <paramref name="assemblies"/>. + </summary> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <param name="assemblies">The assemblies.</param> + <returns> + All visible, non-abstract classes. + </returns> + <exception cref="T:System.ArgumentNullException"><paramref name="assemblies"/> is <see langword="null"/>.</exception> + <exception cref="T:System.ArgumentException"><paramref name="assemblies"/> contains <see langword="null"/> elements.</exception> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while getting types from the assemblies are ignored, and the types + that can be retrieved are returned; otherwise, the original exception is thrown. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.AllClasses.FromApplication(System.Boolean,System.Boolean)"> + <summary> + Returns all visible, non-abstract classes from all assemblies located where the application is installed. + </summary> + <param name="includeUnityAssemblies"><see langword="false"/> to include the Unity assemblies; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <param name="skipOnError"><see langword="true"/> to skip errors; otherwise, <see langword="true"/>.</param> + <returns> + All visible, non-abstract classes. + </returns> + <remarks> + If <paramref name="skipOnError"/> is <see langword="true"/>, all exceptions thrown while loading assemblies or getting types from the assemblies + are ignored, and the types that can be retrieved are returned; otherwise, the original exception is thrown. These exceptions might be wrapped in a + <see cref="T:System.AggregateException"/>. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.DuplicateTypeMappingException"> + <summary> + The exception that is thrown when registering multiple types would result in an type mapping being overwritten. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DuplicateTypeMappingException.#ctor(System.String,System.Type,System.Type,System.Type)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.Unity.DuplicateTypeMappingException"/> class. + </summary> + <param name="name">The name for the mapping.</param> + <param name="mappedFromType">The source type for the mapping.</param> + <param name="currentMappedToType">The type currently mapped.</param> + <param name="newMappedToType">The new type to map.</param> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.Name"> + <summary> + Gets the name for the mapping. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.MappedFromType"> + <summary> + Gets the source type for the mapping. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.CurrentMappedToType"> + <summary> + Gets the type currently mapped. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.DuplicateTypeMappingException.NewMappedToType"> + <summary> + Gets the new type to map. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.RegistrationConvention"> + <summary> + Represents a set of types to register and their registration settings. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetTypes"> + <summary> + Gets types to register. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetFromTypes"> + <summary> + Gets a function to get the types that will be requested for each type to configure. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetName"> + <summary> + Gets a function to get the name to use for the registration of each type. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetLifetimeManager"> + <summary> + Gets a function to get the <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the registration of each type. Defaults to no lifetime management. + </summary> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.Unity.RegistrationConvention.GetInjectionMembers"> + <summary> + Gets a function to get the additional <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects for the registration of each type. Defaults to no injection members. + </summary> + <returns></returns> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions"> + <summary> + Provides a set of convenience overloads to the + <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> interface to support registration of multiple types. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions.RegisterTypes(Microsoft.Practices.Unity.IUnityContainer,System.Collections.Generic.IEnumerable{System.Type},System.Func{System.Type,System.Collections.Generic.IEnumerable{System.Type}},System.Func{System.Type,System.String},System.Func{System.Type,Microsoft.Practices.Unity.LifetimeManager},System.Func{System.Type,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionMember}},System.Boolean)"> + <summary> + Registers the supplied types by using the specified rules for name, lifetime manager, injection members, and registration types. + </summary> + <param name="container">The container to configure.</param> + <param name="types">The types to register. The methods in the <see cref="T:Microsoft.Practices.Unity.AllClasses"/> class can be used to scan assemblies to get types, and further filtering can be performed using LINQ queries.</param> + <param name="getFromTypes">A function that gets the types that will be requested for each type to configure. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithMappings"/> class or a custom function. Defaults to no registration types, and registers only the supplied types.</param> + <param name="getName">A function that gets the name to use for the registration of each type. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithName"/> or a custom function. Defaults to no name.</param> + <param name="getLifetimeManager">A function that gets the <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the registration of each type. It can be a method from the <see cref="T:Microsoft.Practices.Unity.WithLifetime"/> class or a custom function. Defaults to no lifetime management.</param> + <param name="getInjectionMembers">A function that gets the additional <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> objects for the registration of each type. Defaults to no injection members.</param> + <param name="overwriteExistingMappings"><see langword="true"/> to overwrite existing mappings; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <returns> + The container that this method was called on. + </returns> + <exception cref="T:System.ArgumentException">A new registration would overwrite an existing mapping and <paramref name="overwriteExistingMappings"/> is <see langword="false"/>.</exception> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerRegistrationByConventionExtensions.RegisterTypes(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.RegistrationConvention,System.Boolean)"> + <summary> + Registers the types according to the <paramref name="convention"/>. + </summary> + <param name="container">The container to configure.</param> + <param name="convention">The convention to determine which types will be registered and how.</param> + <param name="overwriteExistingMappings"><see langword="true"/> to overwrite existing mappings; otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.</param> + <returns> + The container that this method was called on. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithLifetime"> + <summary> + Provides helper methods to specify the lifetime for a type with registration by convention. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.None(System.Type)"> + <summary> + Returns a <see langword="null"/> <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A lifetime manager</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.ContainerControlled(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A container controlled lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.ExternallyControlled(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>An externally controlled lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Hierarchical(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.HierarchicalLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A hierarchical lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.PerResolve(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A per resolve lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Transient(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.TransientLifetimeManager"/>. + </summary> + <param name="type">The type.</param> + <returns>A transient lifetime manager.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithLifetime.Custom``1(System.Type)"> + <summary> + Returns a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="T">The custom <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> type.</typeparam> + <param name="type">The type.</param> + <returns> + A lifetime manager. + </returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithMappings"> + <summary> + Provides helper methods to map types to the types interfaces to which register them. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.None(System.Type)"> + <summary> + Returns no types. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An empty enumeration.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromMatchingInterface(System.Type)"> + <summary> + Returns an enumeration with the interface that matches the name of <paramref name="implementationType"/>. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with the first interface matching the name of <paramref name="implementationType"/> (for example, if type is MyType, a matching interface is IMyType), + or an empty enumeration if no such interface is found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromAllInterfaces(System.Type)"> + <summary> + Returns an enumeration with all the interfaces implemented by <paramref name="implementationType"/>. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with all the interfaces implemented by the implementation type except <see cref="T:System.IDisposable"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithMappings.FromAllInterfacesInSameAssembly(System.Type)"> + <summary> + Returns an enumeration with all the interfaces implemented by <paramref name="implementationType"/> that belong to the same assembly as implementationType. + </summary> + <param name="implementationType">The type to register.</param> + <returns>An enumeration with all the interfaces implemented by the implementation type that belong to the same assembly.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.WithName"> + <summary> + Provides helper methods to get type names. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.WithName.TypeName(System.Type)"> + <summary> + Returns the type name. + </summary> + <param name="type">The type.</param> + <returns>The type name.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.WithName.Default(System.Type)"> + <summary> + Returns null for the registration name. + </summary> + <param name="type">The type.</param> + <returns><see langword="null"/></returns> + </member> + <member name="T:Microsoft.Practices.Unity.Properties.Resources"> + <summary> + A strongly-typed resource class, for looking up localized strings, etc. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResourceManager"> + <summary> + Returns the cached ResourceManager instance used by this class. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.Culture"> + <summary> + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.AmbiguousInjectionConstructor"> + <summary> + Looks up a localized string similar to The type {0} has multiple constructors of length {1}. Unable to disambiguate.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ArgumentMustNotBeEmpty"> + <summary> + Looks up a localized string similar to The provided string argument must not be empty.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.BuildFailedException"> + <summary> + Looks up a localized string similar to The current build operation (build key {2}) failed: {3} (Strategy type {0}, index {1}). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotConstructInterface"> + <summary> + Looks up a localized string similar to The current type, {0}, is an interface and cannot be constructed. Are you missing a type mapping?. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotExtractTypeFromBuildKey"> + <summary> + Looks up a localized string similar to Cannot extract type from build key {0}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectGenericMethod"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) is an open generic method. Open generic methods cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectIndexer"> + <summary> + Looks up a localized string similar to The property {0} on type {1} is an indexer. Indexed properties cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithOutParam"> + <summary> + Looks up a localized string similar to The method {1} on type {0} has an out parameter. Injection cannot be performed.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithOutParams"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) has at least one out parameter. Methods with out parameters cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectMethodWithRefParams"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) has at least one ref parameter.Methods with ref parameters cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectOpenGenericMethod"> + <summary> + Looks up a localized string similar to The method {1} on type {0} is marked for injection, but it is an open generic method. Injection cannot be performed.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotInjectStaticMethod"> + <summary> + Looks up a localized string similar to The method {0}.{1}({2}) is static. Static methods cannot be injected.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.CannotResolveOpenGenericType"> + <summary> + Looks up a localized string similar to The type {0} is an open generic type. An open generic type cannot be resolved.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ConstructorArgumentResolveOperation"> + <summary> + Looks up a localized string similar to Resolving parameter "{0}" of constructor {1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ConstructorParameterResolutionFailed"> + <summary> + Looks up a localized string similar to The parameter {0} could not be resolved when attempting to call constructor {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.DuplicateTypeMappingException"> + <summary> + Looks up a localized string similar to An attempt to override an existing mapping was detected for type {1} with name "{0}", currently mapped to type {2}, to type {3}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ExceptionNullAssembly"> + <summary> + Looks up a localized string similar to The set of assemblies contains a null element.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ExceptionNullParameterValue"> + <summary> + Looks up a localized string similar to Parameter type inference does not work for null values. Indicate the parameter type explicitly using a properly configured instance of the InjectionParameter or InjectionParameter<T> classes.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.InvokingConstructorOperation"> + <summary> + Looks up a localized string similar to Calling constructor {0}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.InvokingMethodOperation"> + <summary> + Looks up a localized string similar to Calling method {0}.{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.KeyAlreadyPresent"> + <summary> + Looks up a localized string similar to An item with the given key is already present in the dictionary.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.LifetimeManagerInUse"> + <summary> + Looks up a localized string similar to The lifetime manager is already registered. Lifetime managers cannot be reused, please create a new one.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MarkerBuildPlanInvoked"> + <summary> + Looks up a localized string similar to The override marker build plan policy has been invoked. This should never happen, looks like a bug in the container.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MethodArgumentResolveOperation"> + <summary> + Looks up a localized string similar to Resolving parameter "{0}" of method {1}.{2}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MethodParameterResolutionFailed"> + <summary> + Looks up a localized string similar to The value for parameter "{1}" of method {0} could not be resolved. . + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MissingDependency"> + <summary> + Looks up a localized string similar to Could not resolve dependency for build key {0}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MultipleInjectionConstructors"> + <summary> + Looks up a localized string similar to The type {0} has multiple constructors marked with the InjectionConstructor attribute. Unable to disambiguate.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MustHaveOpenGenericType"> + <summary> + Looks up a localized string similar to The supplied type {0} must be an open generic type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.MustHaveSameNumberOfGenericArguments"> + <summary> + Looks up a localized string similar to The supplied type {0} does not have the same number of generic arguments as the target type {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoConstructorFound"> + <summary> + Looks up a localized string similar to The type {0} does not have an accessible constructor.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoMatchingGenericArgument"> + <summary> + Looks up a localized string similar to The type {0} does not have a generic argument named "{1}". + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoOperationExceptionReason"> + <summary> + Looks up a localized string similar to while resolving. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchConstructor"> + <summary> + Looks up a localized string similar to The type {0} does not have a constructor that takes the parameters ({1}).. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchMethod"> + <summary> + Looks up a localized string similar to The type {0} does not have a public method named {1} that takes the parameters ({2}).. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NoSuchProperty"> + <summary> + Looks up a localized string similar to The type {0} does not contain an instance property named {1}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NotAGenericType"> + <summary> + Looks up a localized string similar to The type {0} is not a generic type, and you are attempting to inject a generic parameter named "{1}".. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.NotAnArrayTypeWithRankOne"> + <summary> + Looks up a localized string similar to The type {0} is not an array type with rank 1, and you are attempting to use a [DependencyArray] attribute on a parameter or property with this type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.OptionalDependenciesMustBeReferenceTypes"> + <summary> + Looks up a localized string similar to Optional dependencies must be reference types. The type {0} is a value type.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyNotSettable"> + <summary> + Looks up a localized string similar to The property {0} on type {1} is not settable.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyTypeMismatch"> + <summary> + Looks up a localized string similar to The property {0} on type {1} is of type {2}, and cannot be injected with a value of type {3}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.PropertyValueResolutionFailed"> + <summary> + Looks up a localized string similar to The value for the property "{0}" could not be resolved.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ProvidedStringArgMustNotBeEmpty"> + <summary> + Looks up a localized string similar to The provided string argument must not be empty.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionFailed"> + <summary> + Looks up a localized string similar to Resolution of the dependency failed, type = "{0}", name = "{1}". + Exception occurred while: {2}. + Exception is: {3} - {4} + ----------------------------------------------- + At the time of the exception, the container was: + . + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionTraceDetail"> + <summary> + Looks up a localized string similar to Resolving {0},{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolutionWithMappingTraceDetail"> + <summary> + Looks up a localized string similar to Resolving {0},{1} (mapped from {2}, {3}). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.ResolvingPropertyValueOperation"> + <summary> + Looks up a localized string similar to Resolving value for property {0}.{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.SelectedConstructorHasRefParameters"> + <summary> + Looks up a localized string similar to The constructor {1} selected for type {0} has ref or out parameters. Such parameters are not supported for constructor injection.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.SettingPropertyOperation"> + <summary> + Looks up a localized string similar to Setting value for property {0}.{1}. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.TypeIsNotConstructable"> + <summary> + Looks up a localized string similar to The type {0} cannot be constructed. You must configure the container to supply this value.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.TypesAreNotAssignable"> + <summary> + Looks up a localized string similar to The type {1} cannot be assigned to variables of type {0}.. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Properties.Resources.UnknownType"> + <summary> + Looks up a localized string similar to <unknown>. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions"> + <summary> + Provides extension methods to the <see cref="T:System.Type"/> class due to the introduction + of <see cref="T:System.Reflection.TypeInfo"/> class in the .NET for Windows Store apps. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetConstructor(System.Type,System.Type[])"> + <summary> + Returns the constructor in <paramref name="type"/> that matches the specified constructor parameter types. + </summary> + <param name="type">The type to inspect</param> + <param name="constructorParameters">The constructor parameter types.</param> + <returns>The constructor that matches the specified parameter types.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetMethodsHierarchical(System.Type)"> + <summary> + Returns the non-static declared methods of a type or its base types. + </summary> + <param name="type">The type to inspect</param> + <returns>An enumerable of the <see cref="T:System.Reflection.MethodInfo"/> objects.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetMethodHierarchical(System.Type,System.String,System.Type[])"> + <summary> + Returns the non-static method of a type or its based type. + </summary> + <param name="type">The type to inspect</param> + <param name="methodName">The name of the method to seek.</param> + <param name="closedParameters">The (closed) parameter type signature of the method.</param> + <returns>The discovered <see cref="T:System.Reflection.MethodInfo"/></returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.GetPropertiesHierarchical(System.Type)"> + <summary> + Returns the declared properties of a type or its base types. + </summary> + <param name="type">The type to inspect</param> + <returns>An enumerable of the <see cref="T:System.Reflection.PropertyInfo"/> objects.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.TypeReflectionExtensions.ParametersMatch(System.Reflection.ParameterInfo[],System.Type[])"> + <summary> + Determines if the types in a parameter set ordinally matches the set of supplied types. + </summary> + <param name="parameters"></param> + <param name="closedConstructorParameterTypes"></param> + <returns></returns> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyAttribute"> + <summary> + This attribute is used to mark properties and parameters as targets for injection. + </summary> + <remarks> + For properties, this attribute is necessary for injection to happen. For parameters, + it's not needed unless you want to specify additional information to control how + the parameter is resolved. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyResolutionAttribute"> + <summary> + Base class for attributes that can be placed on parameters + or properties to specify how to resolve the value for + that parameter or property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyResolutionAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.#ctor"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> with no name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.#ctor(System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> with the given name. + </summary> + <param name="name">Name to use when resolving this dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.DependencyAttribute.Name"> + <summary> + The name specified in the constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionConstructorAttribute"> + <summary> + This attribute is used to indicate which constructor to choose when + the container attempts to build a type. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMethodAttribute"> + <summary> + This attribute is used to mark methods that should be called when + the container is building an object. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.DependencyResolutionAttribute"/> used to mark a dependency + as optional - the container will try to resolve it, and return null + if the resolution fails rather than throw. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"/> object. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyAttribute"/> object that + specifies a named dependency. + </summary> + <param name="name">Name of the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyAttribute.CreateResolver(System.Type)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + will be used to get the value for the member this attribute is + applied to. + </summary> + <param name="typeToResolve">Type of parameter or property that + this attribute is decoration.</param> + <returns>The resolver object.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyAttribute.Name"> + <summary> + Name of the dependency. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.CompositeResolverOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that composites other + ResolverOverride objects. The GetResolver operation then + returns the resolver from the first child override that + matches the current context and request. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ResolverOverride"> + <summary> + Base class for all override objects passed in the + <see cref="M:Microsoft.Practices.Unity.IUnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"/> method. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.OnType``1"> + <summary> + Wrap this resolver in one that verifies the type of the object being built. + This allows you to narrow any override down to a specific type easily. + </summary> + <typeparam name="T">Type to constrain the override to.</typeparam> + <returns>The new override.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ResolverOverride.OnType(System.Type)"> + <summary> + Wrap this resolver in one that verifies the type of the object being built. + This allows you to narrow any override down to a specific type easily. + </summary> + <param name="typeToOverride">Type to constrain the override to.</param> + <returns>The new override.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.Add(Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> to the collection + that is checked. + </summary> + <param name="newOverride">item to add.</param> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.AddRange(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a setof <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>s to the collection. + </summary> + <param name="newOverrides">items to add.</param> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.CompositeResolverOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ContainerRegistration"> + <summary> + Class that returns information about the types registered in a container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.RegisteredType"> + <summary> + The type that was passed to the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> method + as the "from" type, or the only type if type mapping wasn't done. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.MappedToType"> + <summary> + The type that this registration is mapped to. If no type mapping was done, the + <see cref="P:Microsoft.Practices.Unity.ContainerRegistration.RegisteredType"/> property and this one will have the same value. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.Name"> + <summary> + Name the type was registered under. Null for default registration. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.LifetimeManagerType"> + <summary> + The registered lifetime manager instance. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ContainerRegistration.LifetimeManager"> + <summary> + The lifetime manager for this registration. + </summary> + <remarks> + This property will be null if this registration is for an open generic.</remarks> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> class that overrides + the value injected whenever there is a dependency of the + given type, regardless of where it appears in the object graph. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride.#ctor(System.Type,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> to override + the given type with the given value. + </summary> + <param name="typeToConstruct">Type of the dependency.</param> + <param name="dependencyValue">Value to use.</param> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverride`1"> + <summary> + A convenience version of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> that lets you + specify the dependency type using generic syntax. + </summary> + <typeparam name="T">Type of the dependency to override.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverride`1.#ctor(System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.DependencyOverride`1"/> object that will + override the given dependency, and pass the given value. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.DependencyOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.DependencyOverride"/> that lets you + specify multiple parameter overrides in one shot rather than having + to construct multiple objects. + </summary> + <remarks> + This class isn't really a collection, it just implements IEnumerable + so that we get use of the nice C# collection initializer syntax. + </remarks> + </member> + <member name="T:Microsoft.Practices.Unity.OverrideCollection`3"> + <summary> + Base helper class for creating collections of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects + for use in passing a bunch of them to the resolve call. This base class provides + the mechanics needed to allow you to use the C# collection initializer syntax. + </summary> + <typeparam name="TOverride">Concrete type of the <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> this class collects.</typeparam> + <typeparam name="TKey">Key used to create the underlying override object.</typeparam> + <typeparam name="TValue">Value that the override returns.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"> + <summary> + Add a new override to the collection with the given key and value. + </summary> + <param name="key">Key - for example, a parameter or property name.</param> + <param name="value">Value - the value to be returned by the override.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.OverrideCollection`3.MakeOverride(`1,`2)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.DependencyOverrides.MakeOverride(System.Type,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.ChildContainerCreated"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.#ctor(Microsoft.Practices.Unity.ExtensionContext)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs"/> object with the + given child container object. + </summary> + <param name="childContext">An <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> for the newly created child + container.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.ChildContainer"> + <summary> + The newly created child container. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ChildContainerCreatedEventArgs.ChildContext"> + <summary> + An extension context for the created child container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ExtensionContext"> + <summary> + The <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> class provides the means for extension objects + to manipulate the internal state of the <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ExtensionContext.RegisterNamedType(System.Type,System.String)"> + <summary> + Store a type/name pair for later resolution. + </summary> + <remarks> + <para> + When users register type mappings (or other things) with a named key, this method + allows you to register that name with the container so that when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"/> + method is called, that name is included in the list that is returned. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> to register.</param> + <param name="name">Name assocated with that type.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Container"> + <summary> + The container that this context is associated with. + </summary> + <value>The <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> object.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Strategies"> + <summary> + The strategies this container uses. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> that the container uses to build objects.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.BuildPlanStrategies"> + <summary> + The strategies this container uses to construct build plans. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> that this container uses when creating + build plans.</value> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Policies"> + <summary> + The policies this container uses. + </summary> + <remarks>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> the that container uses to build objects.</remarks> + </member> + <member name="P:Microsoft.Practices.Unity.ExtensionContext.Lifetime"> + <summary> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> that this container uses. + </summary> + <value>The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> is used to manage <see cref="T:System.IDisposable"/> objects that the container is managing.</value> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.Registering"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.RegisteringInstance"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="E:Microsoft.Practices.Unity.ExtensionContext.ChildContainerCreated"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.IUnityContainer.CreateChildContainer"/> method is called, providing + the newly created child container to extensions to act on as they see fit. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.IUnityContainerExtensionConfigurator"> + <summary> + Base interface for all extension configuration interfaces. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainerExtensionConfigurator.Container"> + <summary> + Retrieve the container instance that we are currently configuring. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.NamedEventArgs"> + <summary> + An EventArgs class that holds a string Name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.NamedEventArgs.#ctor"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.NamedEventArgs"/> with a null name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.NamedEventArgs.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.NamedEventArgs"/> with the given name. + </summary> + <param name="name">Name to store.</param> + </member> + <member name="P:Microsoft.Practices.Unity.NamedEventArgs.Name"> + <summary> + The name. + </summary> + <value>Name used for this event arg object.</value> + </member> + <member name="T:Microsoft.Practices.Unity.RegisterEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.Registering"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterEventArgs.#ctor(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.RegisterEventArgs"/>. + </summary> + <param name="typeFrom">Type to map from.</param> + <param name="typeTo">Type to map to.</param> + <param name="name">Name for the registration.</param> + <param name="lifetimeManager"><see cref="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"/> to manage instances.</param> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.TypeFrom"> + <summary> + Type to map from. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.TypeTo"> + <summary> + Type to map to. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"> + <summary> + <see cref="P:Microsoft.Practices.Unity.RegisterEventArgs.LifetimeManager"/> to manage instances. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"> + <summary> + Event argument class for the <see cref="E:Microsoft.Practices.Unity.ExtensionContext.RegisteringInstance"/> event. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterInstanceEventArgs.#ctor"> + <summary> + Create a default <see cref="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"/> instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.RegisterInstanceEventArgs.#ctor(System.Type,System.Object,System.String,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Create a <see cref="T:Microsoft.Practices.Unity.RegisterInstanceEventArgs"/> instance initialized with the given arguments. + </summary> + <param name="registeredType">Type of instance being registered.</param> + <param name="instance">The instance object itself.</param> + <param name="name">Name to register under, null if default registration.</param> + <param name="lifetimeManager"><see cref="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.LifetimeManager"/> object that handles how + the instance will be owned.</param> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.RegisteredType"> + <summary> + Type of instance being registered. + </summary> + <value> + Type of instance being registered. + </value> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.Instance"> + <summary> + Instance object being registered. + </summary> + <value>Instance object being registered</value> + </member> + <member name="P:Microsoft.Practices.Unity.RegisterInstanceEventArgs.LifetimeManager"> + <summary> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls ownership of + this instance. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerExtension"> + <summary> + Base class for all <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> extension objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.InitializeExtension(Microsoft.Practices.Unity.ExtensionContext)"> + <summary> + The container calls this method when the extension is added. + </summary> + <param name="context">A <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> instance that gives the + extension access to the internals of the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.Initialize"> + <summary> + Initial the container with this extension's functionality. + </summary> + <remarks> + When overridden in a derived class, this method will modify the given + <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> by adding strategies, policies, etc. to + install it's functions into the container.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtension.Remove"> + <summary> + Removes the extension's functions from the container. + </summary> + <remarks> + <para> + This method is called when extensions are being removed from the container. It can be + used to do things like disconnect event handlers or clean up member state. You do not + need to remove strategies or policies here; the container will do that automatically. + </para> + <para> + The default implementation of this method does nothing.</para> + </remarks> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainerExtension.Container"> + <summary> + The container this extension has been added to. + </summary> + <value>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> that this extension has been added to.</value> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainerExtension.Context"> + <summary> + The <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> object used to manipulate + the inner state of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.GenericParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an instance of a generic type parameter should be resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.GenericParameterBase"> + <summary> + Base class for <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> subclasses that let you specify that + an instance of a generic type parameter should be resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameterValue"> + <summary> + Base type for objects that are used to configure parameters for + constructor or method injection, or for getting the value to + be injected into a property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameters(System.Object[])"> + <summary> + Convert the given set of arbitrary values to a sequence of InjectionParameterValue + objects. The rules are: If it's already an InjectionParameterValue, return it. If + it's a Type, return a ResolvedParameter object for that type. Otherwise return + an InjectionParameter object for that value. + </summary> + <param name="values">The values to build the sequence from.</param> + <returns>The resulting converted sequence.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameter(System.Object)"> + <summary> + Convert an arbitrary value to an InjectionParameterValue object. The rules are: + If it's already an InjectionParameterValue, return it. If it's a Type, return a + ResolvedParameter object for that type. Otherwise return an InjectionParameter + object for that value. + </summary> + <param name="value">The value to convert.</param> + <returns>The resulting <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.InjectionParameterValue.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameterBase.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.GenericParameterBase.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericParameter.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.GenericResolvedArrayParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an array containing the registered instances of a generic type parameter + should be resolved. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.#ctor(System.String,System.Object[])"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericResolvedArrayParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + <remarks>A type is considered compatible if it is an array type of rank one + and its element type is a generic type parameter with a name matching this generic + parameter name configured for the receiver.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.GenericResolvedArrayParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.GenericResolvedArrayParameter.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectedMembers"> + <summary> + A Unity container extension that allows you to configure + which constructors, properties, and methods get injected + via an API rather than through attributes. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.Initialize"> + <summary> + Initial the container with this extension's functionality. + </summary> + <remarks> + When overridden in a derived class, this method will modify the given + <see cref="T:Microsoft.Practices.Unity.ExtensionContext"/> by adding strategies, policies, etc. to + install it's functions into the container.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor``1(Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type. + </summary> + <typeparam name="TTypeToInject">Type the injection is being configured for.</typeparam> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor``1(System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <typeparam name="TTypeToInject">Type the injection is being configured for.</typeparam> + <param name="name">Name of registration</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type. + </summary> + <param name="typeToInject">Type to configure.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <param name="typeToInject">Type to configure.</param> + <param name="name">Name of registration.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.InjectedMembers.ConfigureInjectionFor(System.Type,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + API to configure the injection settings for a particular type/name pair. + </summary> + <param name="serviceType">Type of interface/base class being registered (may be null).</param> + <param name="implementationType">Type of actual implementation class being registered.</param> + <param name="name">Name of registration.</param> + <param name="injectionMembers">Objects containing the details on which members to inject and how.</param> + <returns>This extension object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionConstructor"> + <summary> + A class that holds the collection of information + for a constructor, so that the container can + be configured to call this constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMember"> + <summary> + Base class for objects that can be used to configure what + class members get injected by the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMember.AddPolicies(System.Type,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="typeToCreate">Type to register.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMember.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface being registered. If no interface, + this will be null.</param> + <param name="implementationType">Type of concrete type being registered.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionConstructor.#ctor(System.Object[])"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionConstructor"/> that looks + for a constructor with the given set of parameters. + </summary> + <param name="parameterValues">The values for the parameters, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionConstructor.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Interface registered, ignored in this implementation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionFactory"> + <summary> + A class that lets you specify a factory method the container + will use to create the object. + </summary> + <remarks>This is a significantly easier way to do the same + thing the old static factory extension was used for.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.#ctor(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionFactory"/> with + the given factory function. + </summary> + <param name="factoryFunc">Factory function.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.#ctor(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,System.Object})"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.InjectionFactory"/> with + the given factory function. + </summary> + <param name="factoryFunc">Factory function.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionFactory.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface being registered. If no interface, + this will be null. This parameter is ignored in this implementation.</param> + <param name="implementationType">Type of concrete type being registered.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionMethod"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.InjectionMember"/> that configures the + container to call a method as part of buildup. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.#ctor(System.String,System.Object[])"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.InjectionMethod"/> instance which will configure + the container to call the given methods with the given parameters. + </summary> + <param name="methodName">Name of the method to call.</param> + <param name="methodParameters">Parameter values for the method.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Type of interface registered, ignored in this implementation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionMethod.MethodNameMatches(System.Reflection.MemberInfo,System.String)"> + <summary> + A small function to handle name matching. You can override this + to do things like case insensitive comparisons. + </summary> + <param name="targetMethod">MethodInfo for the method you're checking.</param> + <param name="nameToMatch">Name of the method you're looking for.</param> + <returns>True if a match, false if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameter"> + <summary> + A class that holds on to the given value and provides + the required <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> + when the container is configured. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.TypedInjectionValue"> + <summary> + A base class for implementing <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> classes + that deal in explicit types. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TypedInjectionValue.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.TypedInjectionValue"/> that exposes + information about the given <paramref name="parameterType"/>. + </summary> + <param name="parameterType">Type of the parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TypedInjectionValue.MatchesType(System.Type)"> + <summary> + Test to see if this parameter value has a matching type for the given type. + </summary> + <param name="t">Type to check.</param> + <returns>True if this parameter value is compatible with type <paramref name="t"/>, + false if not.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.TypedInjectionValue.ParameterType"> + <summary> + The type of parameter this object represents. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.TypedInjectionValue.ParameterTypeName"> + <summary> + Name for the type represented by this <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/>. + This may be an actual type name or a generic argument name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.#ctor(System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that stores + the given value, using the runtime type of that value as the + type of the parameter. + </summary> + <param name="parameterValue">Value to be injected for this parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.#ctor(System.Type,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that stores + the given value, associated with the given type. + </summary> + <param name="parameterType">Type of the parameter.</param> + <param name="parameterValue">Value of the parameter</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.InjectionParameter"/> that makes it a + little easier to specify the type of the parameter. + </summary> + <typeparam name="TParameter">Type of parameter.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionParameter`1.#ctor(`0)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.InjectionParameter`1"/>. + </summary> + <param name="parameterValue">Value for the parameter.</param> + </member> + <member name="T:Microsoft.Practices.Unity.InjectionProperty"> + <summary> + This class stores information about which properties to inject, + and will configure the container accordingly. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.#ctor(System.String)"> + <summary> + Configure the container to inject the given property name, + resolving the value via the container. + </summary> + <param name="propertyName">Name of the property to inject.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.#ctor(System.String,System.Object)"> + <summary> + Configure the container to inject the given property name, + using the value supplied. This value is converted to an + <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object using the + rules defined by the <see cref="M:Microsoft.Practices.Unity.InjectionParameterValue.ToParameters(System.Object[])"/> + method. + </summary> + <param name="propertyName">Name of property to inject.</param> + <param name="propertyValue">Value for property.</param> + </member> + <member name="M:Microsoft.Practices.Unity.InjectionProperty.AddPolicies(System.Type,System.Type,System.String,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Add policies to the <paramref name="policies"/> to configure the + container to call this constructor with the appropriate parameter values. + </summary> + <param name="serviceType">Interface being registered, ignored in this implemenation.</param> + <param name="implementationType">Type to register.</param> + <param name="name">Name used to resolve the type object.</param> + <param name="policies">Policy list to add policies to.</param> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalGenericParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that lets you specify that + an instance of a generic type parameter should be resolved, providing the <see langword="null"/> + value if resolving fails. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.#ctor(System.String,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.GenericParameter"/> instance that specifies + that the given named generic parameter should be resolved. + </summary> + <param name="genericParameterName">The generic parameter name to resolve.</param> + <param name="resolutionKey">name to use when looking up in the container.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalGenericParameter.DoGetResolverPolicy(System.Type,System.String)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToResolve">The actual type to resolve.</param> + <param name="resolutionKey">The resolution key.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalParameter"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> that can be passed to + <see cref="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"/> to configure a + parameter or property as an optional dependency. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter"/> object that + specifies the given <paramref name="type"/>. + </summary> + <param name="type">Type of the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter"/> object that + specifies the given <paramref name="type"/> and <paramref name="name"/>. + </summary> + <param name="type">Type of the dependency.</param> + <param name="name">Name for the dependency.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.OptionalParameter"></see> that lets you + specify the type of the dependency using generics syntax. + </summary> + <typeparam name="T">Type of the dependency.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter`1.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter`1"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalParameter`1.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalParameter`1"/> with the given + <paramref name="name"/>. + </summary> + <param name="name">Name of the dependency.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayParameter"> + <summary> + A class that stores a type, and generates a + resolver object that resolves all the named instances or the + type registered in a container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.#ctor(System.Type,System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> that + resolves to the given element type and collection of element values. + </summary> + <param name="elementType">The type of elements to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.#ctor(System.Type,System.Type,System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> that + resolves to the given array and element types and collection of element values. + </summary> + <param name="arrayParameterType">The type for the array of elements to resolve.</param> + <param name="elementType">The type of elements to resolve.</param> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter"/> for convenience + when creating them by hand. + </summary> + <typeparam name="TElement">Type of the elements for the array of the parameter.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayParameter`1.#ctor(System.Object[])"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedArrayParameter`1"/> that + resolves to the given element generic type with the given element values. + </summary> + <param name="elementValues">The values for the elements, that will + be converted to <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedParameter"> + <summary> + A class that stores a name and type, and generates a + resolver object that resolves the parameter via the + container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> that + resolves to the given type. + </summary> + <param name="parameterType">Type of this parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> that + resolves the given type and name. + </summary> + <param name="parameterType">Type of this parameter.</param> + <param name="name">Name to use when resolving parameter.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter.GetResolverPolicy(System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance that will + return this types value for the parameter. + </summary> + <param name="typeToBuild">Type that contains the member that needs this parameter. Used + to resolve open generic parameters.</param> + <returns>The <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedParameter`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.Unity.ResolvedParameter"/> for convenience + when creating them by hand. + </summary> + <typeparam name="TParameter">Type of the parameter</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter`1.#ctor"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter`1"/> for the given + generic type and the default name. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedParameter`1.#ctor(System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolvedParameter`1"/> for the given + generic type and name. + </summary> + <param name="name">Name to use to resolve this parameter.</param> + </member> + <member name="T:Microsoft.Practices.Unity.IUnityContainer"> + <summary> + Interface defining the behavior of the Unity dependency injection container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <param name="lifetime"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the requested type with the given name from the container. + </summary> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="resolverOverrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <param name="t">The type requested.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <paramref name="t"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.BuildUp(System.Type,System.Object,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Teardown(System.Object)"> + <summary> + Run an existing object through the container, and clean it up. + </summary> + <param name="o">The object to tear down.</param> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.AddExtension(Microsoft.Practices.Unity.UnityContainerExtension)"> + <summary> + Add an extension object to the container. + </summary> + <param name="extension"><see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.Configure(System.Type)"> + <summary> + Resolve access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <param name="configurationInterface"><see cref="T:System.Type"/> of configuration interface required.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.RemoveAllExtensions"> + <summary> + Remove all installed extensions from this container. + </summary> + <remarks> + <para> + This method removes all extensions from the container, including the default ones + that implement the out-of-the-box behavior. After this method, if you want to use + the container again you will need to either readd the default extensions or replace + them with your own. + </para> + <para> + The registered instances and singletons that have already been set up in this container + do not get removed. + </para> + </remarks> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.IUnityContainer.CreateChildContainer"> + <summary> + Create a child container. + </summary> + <remarks> + A child container shares the parent's configuration, but can be configured with different + settings or lifetime.</remarks> + <returns>The new child container.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainer.Parent"> + <summary> + The parent of this container. + </summary> + <value>The parent container, or null if this container doesn't have one.</value> + </member> + <member name="P:Microsoft.Practices.Unity.IUnityContainer.Registrations"> + <summary> + Get a sequence of <see cref="T:Microsoft.Practices.Unity.ContainerRegistration"/> that describe the current state + of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that holds onto the instance given to it. + When the <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/> is disposed, + the instance is disposed with it. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.SynchronizedLifetimeManager"> + <summary> + Base class for Lifetime managers which need to synchronize calls to + <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/>. + </summary> + <remarks> + <para> + The purpose of this class is to provide a basic implementation of the lifetime manager synchronization pattern. + </para> + <para> + Calls to the <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/> method of a <see cref="T:Microsoft.Practices.Unity.SynchronizedLifetimeManager"/> + instance acquire a lock, and if the instance has not been initialized with a value yet the lock will only be released + when such an initialization takes place by calling the <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"/> method or if + the build request which resulted in the call to the GetValue method fails. + </para> + </remarks> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> + </member> + <member name="T:Microsoft.Practices.Unity.LifetimeManager"> + <summary> + Base class for Lifetime managers - classes that control how + and when instances are created by the Unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that controls how instances are + persisted and recovered from an external store. Used to implement + things like singletons and per-http-request lifetime. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object to store.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy.RemoveValue"> + <summary> + Remove the value this lifetime policy is managing from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"> + <summary> + This interface provides a hook for the builder context to + implement error recovery when a builder strategy throws + an exception. Since we can't get try/finally blocks onto + the call stack for later stages in the chain, we instead + add these objects to the context. If there's an exception, + all the current IRequiresRecovery instances will have + their Recover methods called. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"> + <summary> + A method that does whatever is needed to clean up + as part of cleaning up after an exception. + </summary> + <remarks> + Don't do anything that could throw in this method, + it will cause later recover operations to get skipped + and play real havoc with the stack trace. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + <remarks>Calls to this method acquire a lock which is released only if a non-null value + has been set for the lifetime manager.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SynchronizedGetValue"> + <summary> + Performs the actual retrieval of a value from the backing store associated + with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + <remarks>This method is invoked by <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/> + after it has acquired its lock.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + <remarks>Setting a value will attempt to release the lock acquired by + <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.GetValue"/>.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SynchronizedSetValue(System.Object)"> + <summary> + Performs the actual storage of the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + <remarks>This method is invoked by <see cref="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.SetValue(System.Object)"/> + before releasing its lock.</remarks> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.SynchronizedLifetimeManager.Recover"> + <summary> + A method that does whatever is needed to clean up + as part of cleaning up after an exception. + </summary> + <remarks> + Don't do anything that could throw in this method, + it will cause later recover operations to get skipped + and play real havoc with the stack trace. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.SynchronizedGetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.SynchronizedSetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.Dispose"> + <summary> + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + </summary> + <filterpriority>2</filterpriority> + </member> + <member name="M:Microsoft.Practices.Unity.ContainerControlledLifetimeManager.Dispose(System.Boolean)"> + <summary> + Standard Dispose pattern implementation. Not needed, but it keeps FxCop happy. + </summary> + <param name="disposing">Always true, since we don't have a finalizer.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that holds a weak reference to + it's managed instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ExternallyControlledLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.HierarchicalLifetimeManager"> + <summary> + A special lifetime manager which works like <see cref="T:Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/>, + except that in the presence of child containers, each child gets it's own instance + of the object, instead of sharing one in the common parent. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.LifetimeManagerFactory"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy"/> that + creates instances of the type of the given Lifetime Manager + by resolving them through the container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy"> + <summary> + A builder policy used to create lifetime policy instances. + Used by the LifetimeStrategy when instantiating open + generic types. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy.CreateLifetimePolicy"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/>. + </summary> + <returns>The new instance.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ILifetimeFactoryPolicy.LifetimeType"> + <summary> + The type of Lifetime manager that will be created by this factory. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManagerFactory.#ctor(Microsoft.Practices.Unity.ExtensionContext,System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.LifetimeManagerFactory"/> that will + return instances of the given type, creating them by + resolving through the container. + </summary> + <param name="containerContext">Container to resolve with.</param> + <param name="lifetimeType">Type of LifetimeManager to create.</param> + </member> + <member name="M:Microsoft.Practices.Unity.LifetimeManagerFactory.CreateLifetimePolicy"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/>. + </summary> + <returns>The new instance.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.LifetimeManagerFactory.LifetimeType"> + <summary> + The type of Lifetime manager that will be created by this factory. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"> + <summary> + This is a custom lifetime manager that acts like <see cref="T:Microsoft.Practices.Unity.TransientLifetimeManager"/>, + but also provides a signal to the default build plan, marking the type so that + instances are reused across the build up object graph. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/> object that does not + itself manage an instance. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.#ctor(System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.PerResolveLifetimeManager"/> object that stores the + give value. This value will be returned by <see cref="M:Microsoft.Practices.Unity.LifetimeManager.GetValue"/> + but is not stored in the lifetime manager, nor is the value disposed. + This Lifetime manager is intended only for internal use, which is why the + normal <see cref="M:Microsoft.Practices.Unity.LifetimeManager.SetValue(System.Object)"/> method is not used here. + </summary> + <param name="value">Value to store.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. In this class, + this is a noop, since it has special hooks down in the guts. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PerResolveLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. Noop in this class. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.TransientLifetimeManager"> + <summary> + An <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> implementation that does nothing, + thus ensuring that instances are created new every time. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.GetValue"> + <summary> + Retrieve a value from the backing store associated with this Lifetime policy. + </summary> + <returns>the object desired, or null if no such object is currently stored.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.SetValue(System.Object)"> + <summary> + Stores the given value into backing store for retrieval later. + </summary> + <param name="newValue">The object being stored.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TransientLifetimeManager.RemoveValue"> + <summary> + Remove the given object from backing store. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ArrayResolutionStrategy"> + <summary> + This strategy implements the logic that will call container.ResolveAll + when an array parameter is detected. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ArrayResolutionStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Do the PreBuildUp stage of construction. This is where the actual work is performed. + </summary> + <param name="context">Current build context.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityConstructorSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that is + aware of the build keys used by the Unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that, when implemented, + will determine which constructor to call from the build plan. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicyBase`1.ConstructorLengthComparer.Compare(System.Reflection.ConstructorInfo,System.Reflection.ConstructorInfo)"> + <summary> + Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + </summary> + + <returns> + Value Condition Less than zerox is less than y.Zerox equals y.Greater than zerox is greater than y. + </returns> + + <param name="y">The second object to compare.</param> + <param name="x">The first object to compare.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityConstructorSelectorPolicy.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <remarks> + This implementation looks for the Unity <see cref="T:Microsoft.Practices.Unity.DependencyAttribute"/> on the + parameter and uses it to create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"/> + for this parameter.</remarks> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityMethodSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> that is aware + of the build keys used by the Unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + <typeparam name="TMarkerAttribute">Attribute that marks methods that should + be called.</typeparam> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that will examine the given + types and return a sequence of <see cref="T:System.Reflection.MethodInfo"/> objects + that should be called as part of building the object. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicyBase`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityMethodSelectorPolicy.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityPropertySelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> that is aware of + the build keys used by the unity container. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1"> + <summary> + Base class that provides an implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> + which lets you override how the parameter resolvers are created. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that returns a sequence + of properties that should be injected for the given type. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorBase`1.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.DefaultUnityPropertySelectorPolicy.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.HierarchicalLifetimeStrategy"> + <summary> + A strategy that handles Hierarchical lifetimes across a set of parent/child + containers. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.HierarchicalLifetimeStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> implementation that returns + the value set in the constructor. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> that is used at build plan execution time + to resolve a dependent value. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy.#ctor(System.Object)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy"/> + which will return the given value when resolved. + </summary> + <param name="dependencyValue">The value to return.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.LiteralValueDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that stores a + type and name, and at resolution time puts them together into a + <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.#ctor(System.Type,System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy"/> + with the given type and name. + </summary> + <param name="type">The type.</param> + <param name="name">The name (may be null).</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Resolve the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Type"> + <summary> + The type that this resolver resolves. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ObjectBuilder.NamedTypeDependencyResolverPolicy.Name"> + <summary> + The name that this resolver resolves. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that will attempt to + resolve a value, and return null if it cannot rather than throwing. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.#ctor(System.Type,System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"/> object + that will attempt to resolve the given name and type from the container. + </summary> + <param name="type">Type to resolve. Must be a reference type.</param> + <param name="name">Name to resolve with.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.#ctor(System.Type)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy"/> object + that will attempt to resolve the given type from the container. + </summary> + <param name="type">Type to resolve. Must be a reference type.</param> + </member> + <member name="M:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.DependencyType"> + <summary> + Type this resolver will resolve. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.OptionalDependencyResolverPolicy.Name"> + <summary> + Name this resolver will resolve. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that resolves to + to an array populated with the values that result from resolving other instances + of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy.#ctor(System.Type,Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy[])"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy"/> + with the given type and a collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> + instances to use when populating the result. + </summary> + <param name="elementType">The type.</param> + <param name="elementPolicies">The resolver policies to use when populating an array.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ResolvedArrayWithElementsResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Resolve the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>An array pupulated with the results of resolving the resolver policies.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that selects + the given constructor and creates the appropriate resolvers to call it with + the specified parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy.#ctor(System.Reflection.ConstructorInfo,Microsoft.Practices.Unity.InjectionParameterValue[])"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy"/> that + will return the given constructor, being passed the given injection values + as parameters. + </summary> + <param name="ctor">The constructor to call.</param> + <param name="parameterValues">Set of <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects + that describes how to obtain the values for the constructor parameters.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Choose the constructor to call for the given type. + </summary> + <param name="context">Current build context</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>The chosen constructor.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMemberSelectorHelper"> + <summary> + Helper class for implementing selector policies that need to + set up dependency resolver policies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMemberSelectorHelper.AddParameterResolvers(System.Type,Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue},Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters)"> + <summary> + Add dependency resolvers to the parameter set. + </summary> + <param name="typeToBuild">Type that's currently being built (used to resolve open generics).</param> + <param name="policies">PolicyList to add the resolvers to.</param> + <param name="parameterValues">Objects supplying the dependency resolvers.</param> + <param name="result">Result object to store the keys in.</param> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> implementation that calls the specific + methods with the given parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy.AddMethodAndParameters(System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue})"> + <summary> + Add the given method and parameter collection to the list of methods + that will be returned when the selector's <see cref="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/> + method is called. + </summary> + <param name="method">Method to call.</param> + <param name="parameters">sequence of <see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> objects + that describe how to create the method parameter values.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedMethodsSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Return the sequence of methods to call while building the target object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of methods to call.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy"> + <summary> + An implemnetation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> which returns + the set of specific properties that the selector was configured with. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.AddPropertyAndValue(System.Reflection.PropertyInfo,Microsoft.Practices.Unity.InjectionParameterValue)"> + <summary> + Add a property that will be par of the set returned when the + <see cref="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/> is called. + </summary> + <param name="property">The property to set.</param> + <param name="value"><see cref="T:Microsoft.Practices.Unity.InjectionParameterValue"/> object describing + how to create the value to inject.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ObjectBuilder.SpecifiedPropertiesSelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Returns sequence of properties on the given type that + should be set as part of building that object. + </summary> + <param name="context">Current build context.</param> + <param name="resolverPolicyDestination">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add any + generated resolver objects into.</param> + <returns>Sequence of <see cref="T:System.Reflection.PropertyInfo"/> objects + that contain the properties to set.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage"> + <summary> + The build stages we use in the Unity container + strategy pipeline. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Setup"> + <summary> + First stage. By default, nothing happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.TypeMapping"> + <summary> + Second stage. Type mapping occurs here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Lifetime"> + <summary> + Third stage. lifetime managers are checked here, + and if they're available the rest of the pipeline is skipped. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.PreCreation"> + <summary> + Fourth stage. Reflection over constructors, properties, etc. is + performed here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Creation"> + <summary> + Fifth stage. Instance creation happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.Initialization"> + <summary> + Sixth stage. Property sets and method injection happens here. + </summary> + </member> + <member name="F:Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.PostInitialization"> + <summary> + Seventh and final stage. By default, nothing happens here. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"> + <summary> + Represents the context in which a build-up or tear-down operation runs. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"> + <summary> + Represents the context in which a build-up or tear-down operation runs. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.AddResolverOverrides(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a new set of resolver override objects to the current build operation. + </summary> + <param name="newOverrides"><see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.GetOverriddenResolver(System.Type)"> + <summary> + Get a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object for the given <paramref name="dependencyType"/> + or null if that dependency hasn't been overridden. + </summary> + <param name="dependencyType">Type of the dependency.</param> + <returns>Resolver to use, or null if no override matches for the current operation.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + A convenience method to do a new buildup operation on an existing context. + </summary> + <param name="newBuildKey">Key to use to build up.</param> + <returns>Created object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Action{Microsoft.Practices.ObjectBuilder2.IBuilderContext})"> + <summary> + A convenience method to do a new buildup operation on an existing context. This + overload allows you to specify extra policies which will be in effect for the duration + of the build. + </summary> + <param name="newBuildKey">Key defining what to build up.</param> + <param name="childCustomizationBlock">A delegate that takes a <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/>. This + is invoked with the new child context before the build up process starts. This gives callers + the opportunity to customize the context for the build process.</param> + <returns>Created object.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Strategies"> + <summary> + Gets the head of the strategy chain. + </summary> + <returns> + The strategy that's first in the chain; returns null if there are no + strategies in the chain. + </returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Lifetime"> + <summary> + Gets the <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </summary> + <value> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.OriginalBuildKey"> + <summary> + Gets the original build key for the build operation. + </summary> + <value> + The original build key for the build operation. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.BuildKey"> + <summary> + Get the current build key for the current build operation. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.PersistentPolicies"> + <summary> + The set of policies that were passed into this context. + </summary> + <remarks>This returns the policies passed into the context. + Policies added here will remain after buildup completes.</remarks> + <value>The persistent policies for the current context.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Policies"> + <summary> + Gets the policies for the current context. + </summary> + <remarks>Any policies added to this object are transient + and will be erased at the end of the buildup.</remarks> + <value> + The policies for the current context. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.RecoveryStack"> + <summary> + Gets the collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> objects + that need to execute in event of an exception. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.Existing"> + <summary> + The current object being built up or torn down. + </summary> + <value> + The current object being manipulated by the build operation. May + be null if the object hasn't been created yet.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.BuildComplete"> + <summary> + Flag indicating if the build operation should continue. + </summary> + <value>true means that building should not call any more + strategies, false means continue to the next strategy.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.CurrentOperation"> + <summary> + An object representing what is currently being done in the + build chain. Used to report back errors if there's a failure. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IBuilderContext.ChildContext"> + <summary> + The build context used to resolve a dependency during the build operation represented by this context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor(Microsoft.Practices.ObjectBuilder2.IStrategyChain,Microsoft.Practices.ObjectBuilder2.ILifetimeContainer,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Object)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> class with a <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>, + <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/>, <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> and the + build key used to start this build operation. + </summary> + <param name="chain">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/> to use for this context.</param> + <param name="lifetime">The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> to use for this context.</param> + <param name="policies">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to use for this context.</param> + <param name="originalBuildKey">Build key to start building.</param> + <param name="existing">The existing object to build up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.#ctor(Microsoft.Practices.ObjectBuilder2.IStrategyChain,Microsoft.Practices.ObjectBuilder2.ILifetimeContainer,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.IPolicyList,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Object)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderContext"/> using the explicitly provided + values. + </summary> + <param name="chain">The <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/> to use for this context.</param> + <param name="lifetime">The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> to use for this context.</param> + <param name="persistentPolicies">The set of persistent policies to use for this context.</param> + <param name="transientPolicies">The set of transient policies to use for this context. It is + the caller's responsibility to ensure that the transient and persistent policies are properly + combined.</param> + <param name="buildKey">Build key for this context.</param> + <param name="existing">Existing object to build up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.AddResolverOverrides(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.ResolverOverride})"> + <summary> + Add a new set of resolver override objects to the current build operation. + </summary> + <param name="newOverrides"><see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.GetOverriddenResolver(System.Type)"> + <summary> + Get a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object for the given <paramref name="dependencyType"/> + or null if that dependency hasn't been overridden. + </summary> + <param name="dependencyType">Type of the dependency.</param> + <returns>Resolver to use, or null if no override matches for the current operation.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + A convenience method to do a new buildup operation on an existing context. + </summary> + <param name="newBuildKey">Key to use to build up.</param> + <returns>Created object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContext.NewBuildUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,System.Action{Microsoft.Practices.ObjectBuilder2.IBuilderContext})"> + <summary> + A convenience method to do a new buildup operation on an existing context. This + overload allows you to specify extra policies which will be in effect for the duration + of the build. + </summary> + <param name="newBuildKey">Key defining what to build up.</param> + <param name="childCustomizationBlock">A delegate that takes a <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/>. This + is invoked with the new child context before the build up process starts. This gives callers + the opportunity to customize the context for the build process.</param> + <returns>Created object.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Strategies"> + <summary> + Gets the head of the strategy chain. + </summary> + <returns> + The strategy that's first in the chain; returns null if there are no + strategies in the chain. + </returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.BuildKey"> + <summary> + Get the current build key for the current build operation. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Existing"> + <summary> + The current object being built up or torn down. + </summary> + <value> + The current object being manipulated by the build operation. May + be null if the object hasn't been created yet.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Lifetime"> + <summary> + Gets the <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </summary> + <value> + The <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"/> associated with the build. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.OriginalBuildKey"> + <summary> + Gets the original build key for the build operation. + </summary> + <value> + The original build key for the build operation. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.PersistentPolicies"> + <summary> + The set of policies that were passed into this context. + </summary> + <remarks>This returns the policies passed into the context. + Policies added here will remain after buildup completes.</remarks> + <value>The persistent policies for the current context.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.Policies"> + <summary> + Gets the policies for the current context. + </summary> + <remarks> + Any modifications will be transient (meaning, they will be forgotten when + the outer BuildUp for this context is finished executing). + </remarks> + <value> + The policies for the current context. + </value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.RecoveryStack"> + <summary> + Gets the collection of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> objects + that need to execute in event of an exception. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.BuildComplete"> + <summary> + Flag indicating if the build operation should continue. + </summary> + <value>true means that building should not call any more + strategies, false means continue to the next strategy.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.CurrentOperation"> + <summary> + An object representing what is currently being done in the + build chain. Used to report back errors if there's a failure. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuilderContext.ChildContext"> + <summary> + The build context used to resolve a dependency during the build operation represented by this context. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"> + <summary> + Represents that a dependency could not be resolved. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with no extra information. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the given message. + </summary> + <param name="message">Some random message.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.String,System.Exception)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the given + message and inner exception. + </summary> + <param name="message">Some random message</param> + <param name="innerException">Inner exception.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyMissingException.#ctor(System.Object)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.DependencyMissingException"/> class with the build key of the object begin built. + </summary> + <param name="buildKey">The build key of the object begin built.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"> + <summary> + The exception thrown when injection is attempted on a method + that is an open generic or has out or ref params. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with no + message. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor(System.String)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with the given message + </summary> + <param name="message">Message to return.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException.#ctor(System.String,System.Exception)"> + <summary> + Construct a <see cref="T:Microsoft.Practices.ObjectBuilder2.IllegalInjectionMethodException"/> with the given message + and inner exception. + </summary> + <param name="message">Message to return.</param> + <param name="innerException">Inner exception</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions"> + <summary> + Extension methods to provide convenience overloads over the + <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderContext"/> interface. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.NewBuildUp``1(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Start a recursive build up operation to retrieve the default + value for the given <typeparamref name="TResult"/> type. + </summary> + <typeparam name="TResult">Type of object to build.</typeparam> + <param name="context">Parent context.</param> + <returns>Resulting object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.NewBuildUp``1(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.String)"> + <summary> + Start a recursive build up operation to retrieve the named + implementation for the given <typeparamref name="TResult"/> type. + </summary> + <typeparam name="TResult">Type to resolve.</typeparam> + <param name="context">Parent context.</param> + <param name="name">Name to resolve with.</param> + <returns>The resulting object.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderContextExtensions.AddResolverOverrides(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Add a set of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>s to the context, specified as a + variable argument list. + </summary> + <param name="context">Context to add overrides to.</param> + <param name="overrides">The overrides.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IRecoveryStack"> + <summary> + Data structure that stores the set of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> + objects and executes them when requested. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.Add(Microsoft.Practices.ObjectBuilder2.IRequiresRecovery)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> object to this + list. + </summary> + <param name="recovery">Object to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.ExecuteRecovery"> + <summary> + Execute the <see cref="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"/> method + of everything in the recovery list. Recoveries will execute + in the opposite order of add - it's a stack. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.IRecoveryStack.Count"> + <summary> + Return the number of recovery objects currently in the stack. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer"> + <summary> + Represents a lifetime container. + </summary> + <remarks> + A lifetime container tracks the lifetime of an object, and implements + IDisposable. When the container is disposed, any objects in the + container which implement IDisposable are also disposed. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Add(System.Object)"> + <summary> + Adds an object to the lifetime container. + </summary> + <param name="item">The item to be added to the lifetime container.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Contains(System.Object)"> + <summary> + Determine if a given object is in the lifetime container. + </summary> + <param name="item"> + The item to locate in the lifetime container. + </param> + <returns> + Returns true if the object is contained in the lifetime + container; returns false otherwise. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Remove(System.Object)"> + <summary> + Removes an item from the lifetime container. The item is + not disposed. + </summary> + <param name="item">The item to be removed.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ILifetimeContainer.Count"> + <summary> + Gets the number of references in the lifetime container + </summary> + <value> + The number of references in the lifetime container + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LifetimeContainer"> + <summary> + Represents a lifetime container. + </summary> + <remarks> + A lifetime container tracks the lifetime of an object, and implements + IDisposable. When the container is disposed, any objects in the + container which implement IDisposable are also disposed. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Add(System.Object)"> + <summary> + Adds an object to the lifetime container. + </summary> + <param name="item">The item to be added to the lifetime container.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Contains(System.Object)"> + <summary> + Determine if a given object is in the lifetime container. + </summary> + <param name="item"> + The item to locate in the lifetime container. + </param> + <returns> + Returns true if the object is contained in the lifetime + container; returns false otherwise. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Dispose"> + <summary> + Releases the resources used by the <see cref="T:Microsoft.Practices.ObjectBuilder2.LifetimeContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Dispose(System.Boolean)"> + <summary> + Releases the managed resources used by the DbDataReader and optionally releases the unmanaged resources. + </summary> + <param name="disposing"> + true to release managed and unmanaged resources; false to release only unmanaged resources. + </param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.GetEnumerator"> + <summary> + Returns an enumerator that iterates through the lifetime container. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the life time container. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.System#Collections#IEnumerable#GetEnumerator"> + <summary> + Returns an enumerator that iterates through the lifetime container. + </summary> + <returns> + An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the life time container. + </returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Remove(System.Object)"> + <summary> + Removes an item from the lifetime container. The item is + not disposed. + </summary> + <param name="item">The item to be removed.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.LifetimeContainer.Count"> + <summary> + Gets the number of references in the lifetime container + </summary> + <value> + The number of references in the lifetime container + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"> + <summary> + A custom collection over <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Clear(System.Type,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <param name="policyInterface">The type of policy to remove.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.ClearAll"> + <summary> + Removes all policies from the list. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.ClearDefault(System.Type)"> + <summary> + Removes a default policy. + </summary> + <param name="policyInterface">The type the policy was registered as.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Get(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.GetNoDefault(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies to.</param> + <param name="localOnly">True if the search should be in the local policy list only; otherwise false to search up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.Set(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <param name="policyInterface">The <see cref="T:System.Type"/> of the policy.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IPolicyList.SetDefault(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <param name="policyInterface">The interface to register the policy under.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PolicyList"> + <summary> + A custom collection wrapper over <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderPolicy"/> objects. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.#ctor"> + <summary> + Initialize a new instance of a <see cref="T:Microsoft.Practices.ObjectBuilder2.PolicyList"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.#ctor(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Initialize a new instance of a <see cref="T:Microsoft.Practices.ObjectBuilder2.PolicyList"/> class with another policy list. + </summary> + <param name="innerPolicyList">An inner policy list to search.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Clear(System.Type,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <param name="policyInterface">The type of policy to remove.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.ClearAll"> + <summary> + Removes all policies from the list. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.ClearDefault(System.Type)"> + <summary> + Removes a default policy. + </summary> + <param name="policyInterface">The type the policy was registered as.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Get(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.GetNoDefault(System.Type,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies to.</param> + <param name="localOnly">True if the search should be in the local policy list only; otherwise false to search up the parent chain.</param> + <param name="containingPolicyList">The policy list in the chain that the searched for policy was found in, null if the policy was + not found.</param> + <returns>The policy in the list if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.Set(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <param name="policyInterface">The <see cref="T:System.Type"/> of the policy.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyList.SetDefault(System.Type,Microsoft.Practices.ObjectBuilder2.IBuilderPolicy)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <param name="policyInterface">The interface to register the policy under.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.PolicyList.Count"> + <summary> + Gets the number of items in the locator. + </summary> + <value> + The number of items in the locator. + </value> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions"> + <summary> + Extension methods on <see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to provide convenience + overloads (generic versions, mostly). + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Clear``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Removes an individual policy type for a build key. + </summary> + <typeparam name="TPolicyInterface">The type the policy was registered as.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to remove the policy from.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.ClearDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Removes a default policy. + </summary> + <typeparam name="TPolicyInterface">The type the policy was registered as.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to remove the policy from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Gets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Get(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,System.Boolean)"> + <summary> + Gets an individual policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean)"> + <summary> + Get the non default policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Boolean,Microsoft.Practices.ObjectBuilder2.IPolicyList@)"> + <summary> + Get the non default policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <param name="containingPolicyList">The policy list that actually contains the returned policy.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.GetNoDefault(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Type,System.Object,System.Boolean)"> + <summary> + Get the non default policy. + </summary> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to search.</param> + <param name="policyInterface">The interface the policy is registered under.</param> + <param name="buildKey">The key the policy applies.</param> + <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> + <returns>The policy in the list, if present; returns null otherwise.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.Set``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,``0,System.Object)"> + <summary> + Sets an individual policy. + </summary> + <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add the policy to.</param> + <param name="policy">The policy to be registered.</param> + <param name="buildKey">The key the policy applies.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PolicyListExtensions.SetDefault``1(Microsoft.Practices.ObjectBuilder2.IPolicyList,``0)"> + <summary> + Sets a default policy. When checking for a policy, if no specific individual policy + is available, the default will be used. + </summary> + <typeparam name="TPolicyInterface">The interface to register the policy under.</typeparam> + <param name="policies"><see cref="T:Microsoft.Practices.ObjectBuilder2.IPolicyList"/> to add the policy to.</param> + <param name="policy">The default policy to be registered.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.RecoveryStack"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IRecoveryStack"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.RecoveryStack.Add(Microsoft.Practices.ObjectBuilder2.IRequiresRecovery)"> + <summary> + Add a new <see cref="T:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery"/> object to this + list. + </summary> + <param name="recovery">Object to add.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.RecoveryStack.ExecuteRecovery"> + <summary> + Execute the <see cref="M:Microsoft.Practices.ObjectBuilder2.IRequiresRecovery.Recover"/> method + of everything in the recovery list. Recoveries will execute + in the opposite order of add - it's a stack. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.RecoveryStack.Count"> + <summary> + Return the number of recovery objects currently in the stack. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"> + <summary> + Implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/> which will notify an object about + the completion of a BuildUp operation, or start of a TearDown operation. + </summary> + <remarks> + This strategy checks the object that is passing through the builder chain to see if it + implements IBuilderAware and if it does, it will call <see cref="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnBuiltUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"/> + and <see cref="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnTearingDown"/>. This strategy is meant to be used from the + <see cref="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PostInitialization"/> stage. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy.PreTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a teardown operation. The + PreTearDown method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the teardown operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuilderAware"> + <summary> + Implemented on a class when it wants to receive notifications + about the build process. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnBuiltUp(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Called by the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"/> when the object is being built up. + </summary> + <param name="buildKey">The key of the object that was just built up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuilderAware.OnTearingDown"> + <summary> + Called by the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderAwareStrategy"/> when the object is being torn down. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuilderStage"> + <summary> + Enumeration to represent the object builder stages. + </summary> + <remarks> + The order of the values in the enumeration is the order in which the stages are run. + </remarks> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PreCreation"> + <summary> + Strategies in this stage run before creation. Typical work done in this stage might + include strategies that use reflection to set policies into the context that other + strategies would later use. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.Creation"> + <summary> + Strategies in this stage create objects. Typically you will only have a single policy-driven + creation strategy in this stage. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.Initialization"> + <summary> + Strategies in this stage work on created objects. Typical work done in this stage might + include setter injection and method calls. + </summary> + </member> + <member name="F:Microsoft.Practices.ObjectBuilder2.BuilderStage.PostInitialization"> + <summary> + Strategies in this stage work on objects that are already initialized. Typical work done in + this stage might include looking to see if the object implements some notification interface + to discover when its initialization stage has been completed. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy"> + <summary> + Represents a builder policy for mapping build keys. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"> + <summary> + Represents a builder policy for mapping build keys. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping. This parameter can be null + (called when getting container registrations).</param> + <returns>The new build key.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy"/> with the new build key. + </summary> + <param name="newBuildKey">The new build key.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping, unused in this implementation.</param> + <returns>The new build key.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingStrategy"> + <summary> + Represents a strategy for mapping build keys in the build up operation. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildKeyMappingStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. Looks for the <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"/> + and if found maps the build key for the current operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuildKeyMappingPolicy"/> that can map + generic types. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy.#ctor(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy"/> instance + that will map generic types. + </summary> + <param name="destinationKey">Build key to map to. This must be or contain an open generic type.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.GenericTypeBuildKeyMappingPolicy.Map(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Maps the build key. + </summary> + <param name="buildKey">The build key to map.</param> + <param name="context">Current build context. Used for contextual information + if writing a more sophisticated mapping.</param> + <returns>The new build key.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildOperation"> + <summary> + Base class for the current operation stored in the build context. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildOperation.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.BuildOperation"/>. + </summary> + <param name="typeBeingConstructed">Type currently being built.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.BuildOperation.TypeBeingConstructed"> + <summary> + The type that's currently being built. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.BuildPlanStrategy"> + <summary> + A <see cref="T:Microsoft.Practices.ObjectBuilder2.BuilderStrategy"/> that will look for a build plan + in the current context. If it exists, it invokes it, otherwise + it creates one and stores it for later, and invokes it. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.BuildPlanStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. + </summary> + <param name="context">The context for the operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy"/> that chooses + constructors based on these criteria: first, pick a constructor marked with the + <typeparamref name="TInjectionConstructorMarkerAttribute"/> attribute. If there + isn't one, then choose the constructor with the longest parameter list. If that is ambiguous, + then throw. + </summary> + <exception cref="T:System.InvalidOperationException">Thrown when the constructor to choose is ambiguous.</exception> + <typeparam name="TInjectionConstructorMarkerAttribute">Attribute used to mark the constructor to call.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorSelectorPolicy`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedConstructor"> + <summary> + Objects of this type are the return value from <see cref="M:Microsoft.Practices.ObjectBuilder2.IConstructorSelectorPolicy.SelectConstructor(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + It encapsulates the desired <see cref="T:System.Reflection.ConstructorInfo"/> with the string keys + needed to look up the <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for each + parameter. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1"> + <summary> + Base class for return values from selector policies that + return a memberinfo of some sort plus a list of parameter + keys to look up the parameter resolvers. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters"> + <summary> + Base class for return of selector policies that need + to keep track of a set of parameter keys. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters.AddParameterKey(System.String)"> + <summary> + Add a new parameter key to this object. Keys are assumed + to be in the order of the parameters to the constructor. + </summary> + <param name="newKey">Key for the next parameter to look up.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters.GetParameterKeys"> + <summary> + The set of keys for the constructor parameters. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1.#ctor(`0)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1"/>, storing + the given member info. + </summary> + <param name="memberInfo">Member info to store.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedMemberWithParameters`1.MemberInfo"> + <summary> + The member info stored. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedConstructor.#ctor(System.Reflection.ConstructorInfo)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedConstructor"/> instance which + contains the given constructor. + </summary> + <param name="constructor">The constructor to wrap.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedConstructor.Constructor"> + <summary> + The constructor this object wraps. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"> + <summary> + This class records the information about which constructor argument is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.#ctor(System.Type,System.String,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"/> class. + </summary> + <param name="typeBeingConstructed">The type that is being constructed.</param> + <param name="constructorSignature">A string representing the constructor being called.</param> + <param name="parameterName">Parameter being resolved.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ToString"> + <summary> + Generate the string describing what parameter was being resolved. + </summary> + <returns>The description string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ConstructorSignature"> + <summary> + String describing the constructor being set up. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation.ParameterName"> + <summary> + Parameter that's being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation"> + <summary> + A class that records that a constructor is about to be call, and is + responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.ToString"> + <summary> + Generate the description string. + </summary> + <returns>The string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.InvokingConstructorOperation.ConstructorSignature"> + <summary> + Constructor we're trying to call. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation"> + <summary> + A class that records that a constructor is about to be call, and is + responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.ToString"> + <summary> + Generate the description string. + </summary> + <returns>The string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.InvokingMethodOperation.MethodSignature"> + <summary> + Method we're trying to call. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation"> + <summary> + This class records the information about which constructor argument is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.#ctor(System.Type,System.String,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.ConstructorArgumentResolveOperation"/> class. + </summary> + <param name="typeBeingConstructed">The type that is being constructed.</param> + <param name="methodSignature">A string representing the method being called.</param> + <param name="parameterName">Parameter being resolved.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.ToString"> + <summary> + Generate the string describing what parameter was being resolved. + </summary> + <returns>The description string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.MethodSignature"> + <summary> + String describing the method being set up. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.MethodArgumentResolveOperation.ParameterName"> + <summary> + Parameter that's being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertyOperation"> + <summary> + A base class that holds the information shared by all operations + performed by the container while setting properties. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:System.Object"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"> + <summary> + Generate the description of this operation. + </summary> + <returns>The string.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.PropertyOperation.PropertyName"> + <summary> + The property value currently being resolved. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation"> + <summary> + This class records the information about which property value is currently + being resolved, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:System.Object"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.ResolvingPropertyValueOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation"> + <summary> + This class records the information about which property value is currently + being set, and is responsible for generating the error string required when + an error has occurred. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation.#ctor(System.Type,System.String)"> + <summary> + Initializes a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation"/> class. + </summary> + <param name="typeBeingConstructed">Type property is on.</param> + <param name="propertyName">Name of property being set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SettingPropertyOperation.GetDescriptionFormat"> + <summary> + Get a format string used to create the description. Called by + the base <see cref="M:Microsoft.Practices.ObjectBuilder2.PropertyOperation.ToString"/> method. + </summary> + <returns>The format string.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DeferredResolveBuildPlanPolicy"> + <summary> + Build plan for <see cref="T:System.Func`1"/> that will + return a func that will resolve the requested type + through this container later. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FactoryDelegateBuildPlanPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy"/> that selects + methods by looking for the given <typeparamref name="TMarkerAttribute"/> + attribute on those methods. + </summary> + <typeparam name="TMarkerAttribute">Type of attribute used to mark methods + to inject.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.MethodSelectorPolicy`1.CreateResolver(System.Reflection.ParameterInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> instance for the given + <see cref="T:System.Reflection.ParameterInfo"/>. + </summary> + <param name="parameter">Parameter to create the resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedMethod"> + <summary> + Objects of this type are the return value from <see cref="M:Microsoft.Practices.ObjectBuilder2.IMethodSelectorPolicy.SelectMethods(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + It encapsulates the desired <see cref="T:System.Reflection.MethodInfo"/> with the string keys + needed to look up the <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for each + parameter. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedMethod.#ctor(System.Reflection.MethodInfo)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedMethod"/> instance which + contains the given method. + </summary> + <param name="method">The method</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedMethod.Method"> + <summary> + The constructor this object wraps. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.OverriddenBuildPlanMarkerPolicy.BuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Creates an instance of this build plan's type, or fills + in the existing type if passed in. + </summary> + <param name="context">Context used to build up the object.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.PropertySelectorPolicy`1"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy"/> that looks + for properties marked with the <typeparamref name="TResolutionAttribute"/> + attribute that are also settable and not indexers. + </summary> + <typeparam name="TResolutionAttribute"></typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.PropertySelectorPolicy`1.CreateResolver(System.Reflection.PropertyInfo)"> + <summary> + Create a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> for the given + property. + </summary> + <param name="property">Property to create resolver for.</param> + <returns>The resolver object.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.SelectedProperty"> + <summary> + Objects of this type are returned from + <see cref="M:Microsoft.Practices.ObjectBuilder2.IPropertySelectorPolicy.SelectProperties(Microsoft.Practices.ObjectBuilder2.IBuilderContext,Microsoft.Practices.ObjectBuilder2.IPolicyList)"/>. + This class combines the <see cref="T:System.Reflection.PropertyInfo"/> about + the property with the string key used to look up the resolver + for this property's value. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.SelectedProperty.#ctor(System.Reflection.PropertyInfo,System.String)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.ObjectBuilder2.SelectedProperty"/> + with the given <see cref="T:System.Reflection.PropertyInfo"/> and key. + </summary> + <param name="property">The property.</param> + <param name="key">Key to use to look up the resolver.</param> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedProperty.Property"> + <summary> + PropertyInfo for this property. + </summary> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.SelectedProperty.Key"> + <summary> + Key to look up this property's resolver. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy"> + <summary> + Implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"/>. + </summary> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"> + <summary> + A builder policy that lets you keep track of the current + resolvers and will remove them from the given policy set. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy.AddResolverKey(System.Object)"> + <summary> + Add a new resolver to track by key. + </summary> + <param name="key">Key that was used to add the resolver to the policy set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Remove the currently tracked resolvers from the given policy list. + </summary> + <param name="policies">Policy list to remove the resolvers from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.AddResolverKey(System.Object)"> + <summary> + Add a new resolver to track by key. + </summary> + <param name="key">Key that was used to add the resolver to the policy set.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList)"> + <summary> + Remove the currently tracked resolvers from the given policy list. + </summary> + <param name="policies">Policy list to remove the resolvers from.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.GetTracker(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Get an instance that implements <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverTrackerPolicy"/>, + either the current one in the policy set or creating a new one if it doesn't + exist. + </summary> + <param name="policies">Policy list to look up from.</param> + <param name="buildKey">Build key to track.</param> + <returns>The resolver tracker.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.TrackKey(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object,System.Object)"> + <summary> + Add a key to be tracked to the current tracker. + </summary> + <param name="policies">Policy list containing the resolvers and trackers.</param> + <param name="buildKey">Build key for the resolvers being tracked.</param> + <param name="resolverKey">Key for the resolver.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.DependencyResolverTrackerPolicy.RemoveResolvers(Microsoft.Practices.ObjectBuilder2.IPolicyList,System.Object)"> + <summary> + Remove the resolvers for the given build key. + </summary> + <param name="policies">Policy list containing the build key.</param> + <param name="buildKey">Build key.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that + calls back into the build chain to build up the dependency, passing + a type given at compile time as its build key. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy.#ctor(System.Type)"> + <summary> + Create a new instance storing the given type. + </summary> + <param name="typeToBuild">Type to resolve.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.FixedTypeResolverPolicy.Resolve(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Get the value for a dependency. + </summary> + <param name="context">Current build context.</param> + <returns>The value for the dependency.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain"> + <summary> + This interface defines a standard method to convert any + <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> regardless + of the stage enum into a regular, flat strategy chain. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStagedStrategyChain.MakeStrategyChain"> + <summary> + Convert this <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> into + a flat <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>. + </summary> + <returns>The flattened <see cref="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"/>.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.IStrategyChain"> + <summary> + Represents a chain of responsibility for builder strategies. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.Reverse"> + <summary> + Reverse the order of the strategy chain. + </summary> + <returns>The reversed strategy chain.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.ExecuteBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the Buildup methods on the strategies. + </summary> + <param name="context">Context for the build process.</param> + <returns>The build up object</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.IStrategyChain.ExecuteTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the TearDown methods on the strategies. + </summary> + <param name="context">Context for the teardown process.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy"> + <summary> + An <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/> implementation that uses + a <see cref="T:Microsoft.Practices.ObjectBuilder2.ILifetimePolicy"/> to figure out if an object + has already been created and to update or remove that + object from some backing store. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy.PreBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PreBuildUp method is called when the chain is being executed in the + forward direction. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.LifetimeStrategy.PostBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Called during the chain of responsibility for a build operation. The + PostBuildUp method is called when the chain has finished the PreBuildUp + phase and executes in reverse order from the PreBuildUp calls. + </summary> + <param name="context">Context of the build operation.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"> + <summary> + Represents a chain of responsibility for builder strategies partitioned by stages. + </summary> + <typeparam name="TStageEnum">The stage enumeration to partition the strategies.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.#ctor"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.#ctor(Microsoft.Practices.ObjectBuilder2.StagedStrategyChain{`0})"> + <summary> + Initialize a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1"/> class with an inner strategy chain to use when building. + </summary> + <param name="innerChain">The inner strategy chain to use first when finding strategies in the build operation.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.Add(Microsoft.Practices.ObjectBuilder2.IBuilderStrategy,`0)"> + <summary> + Adds a strategy to the chain at a particular stage. + </summary> + <param name="strategy">The strategy to add to the chain.</param> + <param name="stage">The stage to add the strategy.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.AddNew``1(`0)"> + <summary> + Add a new strategy for the <paramref name="stage"/>. + </summary> + <typeparam name="TStrategy">The <see cref="T:System.Type"/> of <see cref="T:Microsoft.Practices.ObjectBuilder2.IBuilderStrategy"/></typeparam> + <param name="stage">The stage to add the strategy.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.Clear"> + <summary> + Clear the current strategy chain list. + </summary> + <remarks> + This will not clear the inner strategy chain if this instane was created with one. + </remarks> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StagedStrategyChain`1.MakeStrategyChain"> + <summary> + Makes a strategy chain based on this instance. + </summary> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/>.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"> + <summary> + Represents a chain of responsibility for builder strategies. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.#ctor"> + <summary> + Initialzie a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/> class. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.#ctor(System.Collections.IEnumerable)"> + <summary> + Initialzie a new instance of the <see cref="T:Microsoft.Practices.ObjectBuilder2.StrategyChain"/> class with a colleciton of strategies. + </summary> + <param name="strategies">A collection of strategies to initialize the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.Add(Microsoft.Practices.ObjectBuilder2.IBuilderStrategy)"> + <summary> + Adds a strategy to the chain. + </summary> + <param name="strategy">The strategy to add to the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.AddRange(System.Collections.IEnumerable)"> + <summary> + Adds strategies to the chain. + </summary> + <param name="strategyEnumerable">The strategies to add to the chain.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.Reverse"> + <summary> + Reverse the order of the strategy chain. + </summary> + <returns>The reversed strategy chain.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteBuildUp(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context to build up. + </summary> + <param name="context">Context for the build processes.</param> + <returns>The build up object</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.ExecuteTearDown(Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Execute this strategy chain against the given context, + calling the TearDown methods on the strategies. + </summary> + <param name="context">Context for the teardown process.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.System#Collections#Generic#IEnumerable{Microsoft#Practices#ObjectBuilder2#IBuilderStrategy}#GetEnumerator"> + <summary> + Returns an enumerator that iterates through the collection. + </summary> + + <returns> + A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection. + </returns> + <filterpriority>1</filterpriority> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.StrategyChain.GetEnumerator"> + <summary> + Returns an enumerator that iterates through a collection. + </summary> + + <returns> + An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection. + </returns> + <filterpriority>2</filterpriority> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions"> + <summary> + The almost inevitable collection of extra helper methods on + <see cref="T:System.Collections.Generic.IEnumerable`1"/> to augment the rich set of what + Linq already gives us. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})"> + <summary> + Execute the provided <paramref name="action"/> on every item in <paramref name="sequence"/>. + </summary> + <typeparam name="TItem">Type of the items stored in <paramref name="sequence"/></typeparam> + <param name="sequence">Sequence of items to process.</param> + <param name="action">Code to run over each item.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.JoinStrings``1(System.Collections.Generic.IEnumerable{``0},System.String,System.Func{``0,System.String})"> + <summary> + Create a single string from a sequenc of items, separated by the provided <paramref name="separator"/>, + and with the conversion to string done by the given <paramref name="converter"/>. + </summary> + <remarks>This method does basically the same thing as <see cref="M:System.String.Join(System.String,System.String[])"/>, + but will work on any sequence of items, not just arrays.</remarks> + <typeparam name="TItem">Type of items in the sequence.</typeparam> + <param name="sequence">Sequence of items to convert.</param> + <param name="separator">Separator to place between the items in the string.</param> + <param name="converter">The conversion function to change TItem -> string.</param> + <returns>The resulting string.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.EnumerableExtensions.JoinStrings``1(System.Collections.Generic.IEnumerable{``0},System.String)"> + <summary> + Create a single string from a sequenc of items, separated by the provided <paramref name="separator"/>, + and with the conversion to string done by the item's <see cref="M:System.Object.ToString"/> method. + </summary> + <remarks>This method does basically the same thing as <see cref="M:System.String.Join(System.String,System.String[])"/>, + but will work on any sequence of items, not just arrays.</remarks> + <typeparam name="TItem">Type of items in the sequence.</typeparam> + <param name="sequence">Sequence of items to convert.</param> + <param name="separator">Separator to place between the items in the string.</param> + <returns>The resulting string.</returns> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"> + <summary> + Build key used to combine a type object with a string name. Used by + ObjectBuilder to indicate exactly what is being built. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.#ctor(System.Type,System.String)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance with the given + type and name. + </summary> + <param name="type"><see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> to build.</param> + <param name="name">Key to use to look up type mappings and singletons.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance for the default + buildup of the given type. + </summary> + <param name="type"><see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> to build.</param> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Make``1"> + <summary> + This helper method creates a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance. It is + initialized for the default key for the given type. + </summary> + <typeparam name="T">Type to build.</typeparam> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Make``1(System.String)"> + <summary> + This helper method creates a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance for + the given type and key. + </summary> + <typeparam name="T">Type to build</typeparam> + <param name="name">Key to use to look up type mappings and singletons.</param> + <returns>A new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instance initialized with the given type and name.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Equals(System.Object)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type. Also, comparing + against a different type will also return false.</remarks> + <param name="obj">Object to compare to.</param> + <returns>True if the two keys are equal, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.GetHashCode"> + <summary> + Calculate a hash code for this instance. + </summary> + <returns>A hash code.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.op_Equality(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances for equality. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type.</remarks> + <param name="left">First of the two keys to compare.</param> + <param name="right">Second of the two keys to compare.</param> + <returns>True if the values of the keys are the same, else false.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.op_Inequality(Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey,Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey)"> + <summary> + Compare two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances for inequality. + </summary> + <remarks>Two <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> instances compare equal + if they contain the same name and the same type. If either field differs + the keys are not equal.</remarks> + <param name="left">First of the two keys to compare.</param> + <param name="right">Second of the two keys to compare.</param> + <returns>false if the values of the keys are the same, else true.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.ToString"> + <summary> + Formats the build key as a string (primarily for debugging). + </summary> + <returns>A readable string representation of the build key.</returns> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"> + <summary> + Return the <see cref="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Type"/> stored in this build key. + </summary> + <value>The type to build.</value> + </member> + <member name="P:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey.Name"> + <summary> + Returns the name stored in this build key. + </summary> + <remarks>The name to use when building.</remarks> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"> + <summary> + A generic version of <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey"/> so that + you can new up a key using generic syntax. + </summary> + <typeparam name="T">Type for the key.</typeparam> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1.#ctor"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"/> that + specifies the given type. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1.#ctor(System.String)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.ObjectBuilder2.NamedTypeBuildKey`1"/> that + specifies the given type and name. + </summary> + <param name="name">Name for the key.</param> + </member> + <member name="T:Microsoft.Practices.ObjectBuilder2.Sequence"> + <summary> + A series of helper methods to deal with sequences - + objects that implement <see cref="T:System.Collections.Generic.IEnumerable`1"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.Sequence.Collect``1(``0[])"> + <summary> + A function that turns an arbitrary parameter list into an + <see cref="T:System.Collections.Generic.IEnumerable`1"/>. + </summary> + <typeparam name="T">Type of arguments.</typeparam> + <param name="arguments">The items to put into the collection.</param> + <returns>An array that contains the values of the <paramref name="arguments"/>.</returns> + </member> + <member name="M:Microsoft.Practices.ObjectBuilder2.Sequence.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})"> + <summary> + Given two sequences, return a new sequence containing the corresponding values + from each one. + </summary> + <typeparam name="TFirstSequenceElement">Type of first sequence.</typeparam> + <typeparam name="TSecondSequenceElement">Type of second sequence.</typeparam> + <param name="sequence1">First sequence of items.</param> + <param name="sequence2">Second sequence of items.</param> + <returns>New sequence of pairs. This sequence ends when the shorter of sequence1 and sequence2 does.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ParameterOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> class that lets you + override a named parameter passed to a constructor. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverride.#ctor(System.String,System.Object)"> + <summary> + Construct a new <see cref="T:Microsoft.Practices.Unity.ParameterOverride"/> object that will + override the given named constructor parameter, and pass the given + value. + </summary> + <param name="parameterName">Name of the constructor parameter.</param> + <param name="parameterValue">Value to pass for the constructor.</param> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ParameterOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.ParameterOverride"/> that lets you + specify multiple parameter overrides in one shot rather than having + to construct multiple objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ParameterOverrides.MakeOverride(System.String,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.PropertyOverride"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that lets you override + the value for a specified property. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverride.#ctor(System.String,System.Object)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.PropertyOverride"/>. + </summary> + <param name="propertyName">The property name.</param> + <param name="propertyValue">Value to use for the property.</param> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.PropertyOverrides"> + <summary> + A convenience form of <see cref="T:Microsoft.Practices.Unity.PropertyOverride"/> that lets you + specify multiple property overrides in one shot rather than having + to construct multiple objects. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.PropertyOverrides.MakeOverride(System.String,System.Object)"> + <summary> + When implemented in derived classes, this method is called from the <see cref="M:Microsoft.Practices.Unity.OverrideCollection`3.Add(`1,`2)"/> + method to create the actual <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> objects. + </summary> + <param name="key">Key value to create the resolver.</param> + <param name="value">Value to store in the resolver.</param> + <returns>The created <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.ResolutionFailedException"> + <summary> + The exception thrown by the Unity container when + an attempt to resolve a dependency fails. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.ResolutionFailedException.#ctor(System.Type,System.String,System.Exception,Microsoft.Practices.ObjectBuilder2.IBuilderContext)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.ResolutionFailedException"/> that records + the exception for the given type and name. + </summary> + <param name="typeRequested">Type requested from the container.</param> + <param name="nameRequested">Name requested from the container.</param> + <param name="innerException">The actual exception that caused the failure of the build.</param> + <param name="context">The build context representing the failed operation.</param> + </member> + <member name="P:Microsoft.Practices.Unity.ResolutionFailedException.TypeRequested"> + <summary> + The type that was being requested from the container at the time of failure. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.ResolutionFailedException.NameRequested"> + <summary> + The name that was being requested from the container at the time of failure. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration"> + <summary> + Interface defining the configuration interface exposed by the + Static Factory extension. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration.RegisterFactory``1(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.IStaticFactoryConfiguration.RegisterFactory``1(System.String,System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/> and <paramref name="name"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="name">The name that will be used when requesting to resolve this type.</param> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension"> + <summary> + A <see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> that lets you register a + delegate with the container to create an object, rather than calling + the object's constructor. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.Initialize"> + <summary> + Initialize this extension. This particular extension requires no + initialization work. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.RegisterFactory``1(System.String,System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/> and <paramref name="name"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="name">The name that will be used when requesting to resolve this type.</param> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.StaticFactory.StaticFactoryExtension.RegisterFactory``1(System.Func{Microsoft.Practices.Unity.IUnityContainer,System.Object})"> + <summary> + Register the given factory delegate to be called when the container is + asked to resolve <typeparamref name="TTypeToBuild"/>. + </summary> + <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> + <param name="factoryMethod">Delegate to invoke to create the instance.</param> + <returns>The container extension object this method was invoked on.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.TypeBasedOverride"> + <summary> + An implementation of <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/> that + acts as a decorator over another <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>. + This checks to see if the current type being built is the + right one before checking the inner <see cref="T:Microsoft.Practices.Unity.ResolverOverride"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride.#ctor(System.Type,Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride"/> + </summary> + <param name="targetType">Type to check for.</param> + <param name="innerOverride">Inner override to check after type matches.</param> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride.GetResolver(Microsoft.Practices.ObjectBuilder2.IBuilderContext,System.Type)"> + <summary> + Return a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> that can be used to give a value + for the given desired dependency. + </summary> + <param name="context">Current build context.</param> + <param name="dependencyType">Type of dependency desired.</param> + <returns>a <see cref="T:Microsoft.Practices.ObjectBuilder2.IDependencyResolverPolicy"/> object if this override applies, null if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.TypeBasedOverride`1"> + <summary> + A convenience version of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride"/> that lets you + specify the type to construct via generics syntax. + </summary> + <typeparam name="T">Type to check for.</typeparam> + </member> + <member name="M:Microsoft.Practices.Unity.TypeBasedOverride`1.#ctor(Microsoft.Practices.Unity.ResolverOverride)"> + <summary> + Create an instance of <see cref="T:Microsoft.Practices.Unity.TypeBasedOverride`1"/>. + </summary> + <param name="innerOverride">Inner override to check after type matches.</param> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainer"> + <summary> + A simple, extensible dependency injection container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.#ctor"> + <summary> + Create a default <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.#ctor(Microsoft.Practices.Unity.UnityContainer)"> + <summary> + Create a <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> with the given parent container. + </summary> + <param name="parent">The parent <see cref="T:Microsoft.Practices.Unity.UnityContainer"/>. The current object + will apply its own settings first, and then check the parent for additional ones.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RegisterType(System.Type,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + RegisterType a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + RegisterType an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <param name="lifetime"> + <para>If true, the container will take over the lifetime of the instance, + calling Dispose on it (if it's <see cref="T:System.IDisposable"/>) when the container is Disposed.</para> + <para> + If false, container will not maintain a strong reference to <paramref name="instance"/>. User is reponsible + for disposing instance, and for keeping the instance from being garbage collected.</para></param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Resolve(System.Type,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Get an instance of the requested type with the given name from the container. + </summary> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="resolverOverrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.ResolveAll(System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <param name="t">The type requested.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <paramref name="t"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.BuildUp(System.Type,System.Object,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Teardown(System.Object)"> + <summary> + Run an existing object through the container, and clean it up. + </summary> + <param name="o">The object to tear down.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.AddExtension(Microsoft.Practices.Unity.UnityContainerExtension)"> + <summary> + Add an extension object to the container. + </summary> + <param name="extension"><see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Configure(System.Type)"> + <summary> + Get access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <param name="configurationInterface"><see cref="T:System.Type"/> of configuration interface required.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.RemoveAllExtensions"> + <summary> + Remove all installed extensions from this container. + </summary> + <remarks> + <para> + This method removes all extensions from the container, including the default ones + that implement the out-of-the-box behavior. After this method, if you want to use + the container again you will need to either readd the default extensions or replace + them with your own. + </para> + <para> + The registered instances and singletons that have already been set up in this container + do not get removed. + </para> + </remarks> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.CreateChildContainer"> + <summary> + Create a child container. + </summary> + <remarks> + A child container shares the parent's configuration, but can be configured with different + settings or lifetime.</remarks> + <returns>The new child container.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Dispose"> + <summary> + Dispose this container instance. + </summary> + <remarks> + Disposing the container also disposes any child containers, + and disposes any instances whose lifetimes are managed + by the container. + </remarks> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.Dispose(System.Boolean)"> + <summary> + Dispose this container instance. + </summary> + <remarks> + This class doesn't have a finalizer, so <paramref name="disposing"/> will always be true.</remarks> + <param name="disposing">True if being called from the IDisposable.Dispose + method, false if being called from a finalizer.</param> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainer.ClearExistingBuildPlan(System.Type,System.String)"> + <summary> + Remove policies associated with building this type. This removes the + compiled build plan so that it can be rebuilt with the new settings + the next time this type is resolved. + </summary> + <param name="typeToInject">Type of object to clear the plan for.</param> + <param name="name">Name the object is being registered with.</param> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainer.Parent"> + <summary> + The parent of this container. + </summary> + <value>The parent container, or null if this container doesn't have one.</value> + </member> + <member name="P:Microsoft.Practices.Unity.UnityContainer.Registrations"> + <summary> + Get a sequence of <see cref="T:Microsoft.Practices.Unity.ContainerRegistration"/> that describe the current state + of the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainer.ExtensionContextImpl"> + <summary> + Implementation of the ExtensionContext that is actually used + by the UnityContainer implementation. + </summary> + <remarks> + This is a nested class so that it can access state in the + container that would otherwise be inaccessible. + </remarks> + </member> + <member name="E:Microsoft.Practices.Unity.UnityContainer.ExtensionContextImpl.RegisteringInstance"> + <summary> + This event is raised when the <see cref="M:Microsoft.Practices.Unity.UnityContainer.RegisterInstance(System.Type,System.String,System.Object,Microsoft.Practices.Unity.LifetimeManager)"/> method, + or one of its overloads, is called. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityContainerExtensions"> + <summary> + Extension class that adds a set of convenience overloads to the + <see cref="T:Microsoft.Practices.Unity.IUnityContainer"/> interface. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type with specific members to be injected. + </summary> + <typeparam name="T">Type this registration is for.</typeparam> + <param name="container">Container to configure.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + <para> + This method is used to tell the container that when asked for type <typeparamref name="TFrom"/>, + actually return an instance of type <typeparamref name="TTo"/>. This is very useful for + getting instances of interfaces. + </para> + <para> + This overload registers a default mapping and transient lifetime. + </para> + </remarks> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + This method is used to tell the container that when asked for type <typeparamref name="TFrom"/>, + actually return an instance of type <typeparamref name="TTo"/>. This is very useful for + getting instances of interfaces. + </remarks> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name of this mapping.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``2(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <typeparam name="TFrom"><see cref="T:System.Type"/> that will be requested.</typeparam> + <typeparam name="TTo"><see cref="T:System.Type"/> that will actually be returned.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to apply the <paramref name="lifetimeManager"/> to.</typeparam> + <param name="container">Container to configure.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to configure injection on.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name that will be used to request the type.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <typeparam name="T">The type to apply the <paramref name="lifetimeManager"/> to.</typeparam> + <param name="container">Container to configure.</param> + <param name="name">Name that will be used to request the type.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type with specific members to be injected. + </summary> + <param name="container">Container to configure.</param> + <param name="t">Type this registration is for.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + <para> + This method is used to tell the container that when asked for type <paramref name="from"/>, + actually return an instance of type <paramref name="to"/>. This is very useful for + getting instances of interfaces. + </para> + <para> + This overload registers a default mapping. + </para> + </remarks> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container. + </summary> + <remarks> + This method is used to tell the container that when asked for type <paramref name="from"/>, + actually return an instance of type <paramref name="to"/>. This is very useful for + getting instances of interfaces. + </remarks> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Type,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a type mapping with the container, where the created instances will use + the given <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/>. + </summary> + <param name="container">Container to configure.</param> + <param name="from"><see cref="T:System.Type"/> that will be requested.</param> + <param name="to"><see cref="T:System.Type"/> that will actually be returned.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to apply the <paramref name="lifetimeManager"/> to.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to configure in the container.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterType(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,Microsoft.Practices.Unity.LifetimeManager,Microsoft.Practices.Unity.InjectionMember[])"> + <summary> + Register a <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> for the given type and name with the container. + No type mapping is performed for this type. + </summary> + <param name="container">Container to configure.</param> + <param name="t">The <see cref="T:System.Type"/> to apply the <paramref name="lifetimeManager"/> to.</param> + <param name="name">Name to use for registration, null if a default registration.</param> + <param name="lifetimeManager">The <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> that controls the lifetime + of the returned instance.</param> + <param name="injectionMembers">Injection configuration objects.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,``0)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration and has the container take over the lifetime of the instance.</para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="container">Container to configure.</param> + <param name="instance">Object to returned.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,``0,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration (name = null). + </para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="container">Container to configure.</param> + <param name="instance">Object to returned.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,System.String,``0)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload automatically has the container take ownership of the <paramref name="instance"/>.</para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="instance">Object to returned.</param> + <param name="container">Container to configure.</param> + <param name="name">Name for registration.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance``1(Microsoft.Practices.Unity.IUnityContainer,System.String,``0,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + </remarks> + <typeparam name="TInterface">Type of instance to register (may be an implemented interface instead of the full type).</typeparam> + <param name="instance">Object to returned.</param> + <param name="container">Container to configure.</param> + <param name="name">Name for registration.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration and has the container take over the lifetime of the instance.</para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object,Microsoft.Practices.Unity.LifetimeManager)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload does a default registration (name = null). + </para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="lifetimeManager"> + <see cref="T:Microsoft.Practices.Unity.LifetimeManager"/> object that controls how this instance will be managed by the container.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.RegisterInstance(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String,System.Object)"> + <summary> + Register an instance with the container. + </summary> + <remarks> + <para> + Instance registration is much like setting a type as a singleton, except that instead + of the container creating the instance the first time it is requested, the user + creates the instance ahead of type and adds that instance to the container. + </para> + <para> + This overload automatically has the container take ownership of the <paramref name="instance"/>.</para> + </remarks> + <param name="container">Container to configure.</param> + <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> + <param name="instance">Object to returned.</param> + <param name="name">Name for registration.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the default requested type from the container. + </summary> + <typeparam name="T"><see cref="T:System.Type"/> of object to get from the container.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve``1(Microsoft.Practices.Unity.IUnityContainer,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the requested type with the given name from the container. + </summary> + <typeparam name="T"><see cref="T:System.Type"/> of object to get from the container.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="name">Name of the object to retrieve.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Resolve(Microsoft.Practices.Unity.IUnityContainer,System.Type,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Resolve an instance of the default requested type from the container. + </summary> + <param name="container">Container to resolve from.</param> + <param name="t"><see cref="T:System.Type"/> of object to get from the container.</param> + <param name="overrides">Any overrides for the resolve call.</param> + <returns>The retrieved object.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.ResolveAll``1(Microsoft.Practices.Unity.IUnityContainer,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Return instances of all registered types requested. + </summary> + <remarks> + <para> + This method is useful if you've registered multiple types with the same + <see cref="T:System.Type"/> but different names. + </para> + <para> + Be aware that this method does NOT return an instance for the default (unnamed) registration. + </para> + </remarks> + <typeparam name="T">The type requested.</typeparam> + <param name="container">Container to resolve from.</param> + <param name="resolverOverrides">Any overrides for the resolve calls.</param> + <returns>Set of objects of type <typeparamref name="T"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp``1(Microsoft.Practices.Unity.IUnityContainer,``0,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para> + <para> + This overload uses the default registrations. + </para> + </remarks> + <typeparam name="T"><see cref="T:System.Type"/> of object to perform injection on.</typeparam> + <param name="container">Container to resolve through.</param> + <param name="existing">Instance to build up.</param> + <param name="resolverOverrides">Any overrides for the buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <typeparamref name="T"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp``1(Microsoft.Practices.Unity.IUnityContainer,``0,System.String,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para></remarks> + <typeparam name="T"><see cref="T:System.Type"/> of object to perform injection on.</typeparam> + <param name="container">Conatiner to resolve through.</param> + <param name="existing">Instance to build up.</param> + <param name="name">name to use when looking up the typemappings and other configurations.</param> + <param name="resolverOverrides">Any overrides for the Buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <typeparamref name="T"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.BuildUp(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.Object,Microsoft.Practices.Unity.ResolverOverride[])"> + <summary> + Run an existing object through the container and perform injection on it. + </summary> + <remarks> + <para> + This method is useful when you don't control the construction of an + instance (ASP.NET pages or objects created via XAML, for instance) + but you still want properties and other injection performed. + </para> + <para> + This overload uses the default registrations. + </para> + </remarks> + <param name="container">Container to resolve through.</param> + <param name="t"><see cref="T:System.Type"/> of object to perform injection on.</param> + <param name="existing">Instance to build up.</param> + <param name="resolverOverrides">Any overrides for the Buildup.</param> + <returns>The resulting object. By default, this will be <paramref name="existing"/>, but + container extensions may add things like automatic proxy creation which would + cause this to return a different object (but still type compatible with <paramref name="t"/>).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.AddNewExtension``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Creates a new extension object and adds it to the container. + </summary> + <typeparam name="TExtension">Type of <see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add. The extension type + will be resolved from within the supplied <paramref name="container"/>.</typeparam> + <param name="container">Container to add the extension to.</param> + <returns>The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.Configure``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Resolve access to a configuration interface exposed by an extension. + </summary> + <remarks>Extensions can expose configuration interfaces as well as adding + strategies and policies to the container. This method walks the list of + added extensions and returns the first one that implements the requested type. + </remarks> + <typeparam name="TConfigurator">The configuration interface required.</typeparam> + <param name="container">Container to configure.</param> + <returns>The requested extension's configuration interface, or null if not found.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered(Microsoft.Practices.Unity.IUnityContainer,System.Type)"> + <summary> + Check if a particular type has been registered with the container with + the default name. + </summary> + <param name="container">Container to inspect.</param> + <param name="typeToCheck">Type to check registration for.</param> + <returns>True if this type has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered(Microsoft.Practices.Unity.IUnityContainer,System.Type,System.String)"> + <summary> + Check if a particular type/name pair has been registered with the container. + </summary> + <param name="container">Container to inspect.</param> + <param name="typeToCheck">Type to check registration for.</param> + <param name="nameToCheck">Name to check registration for.</param> + <returns>True if this type/name pair has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered``1(Microsoft.Practices.Unity.IUnityContainer)"> + <summary> + Check if a particular type has been registered with the container with the default name. + </summary> + <typeparam name="T">Type to check registration for.</typeparam> + <param name="container">Container to inspect.</param> + <returns>True if this type has been registered, false if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.UnityContainerExtensions.IsRegistered``1(Microsoft.Practices.Unity.IUnityContainer,System.String)"> + <summary> + Check if a particular type/name pair has been registered with the container. + </summary> + <typeparam name="T">Type to check registration for.</typeparam> + <param name="container">Container to inspect.</param> + <param name="nameToCheck">Name to check registration for.</param> + <returns>True if this type/name pair has been registered, false if not.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension"> + <summary> + This extension supplies the default behavior of the UnityContainer API + by handling the context events and setting policies. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension.Initialize"> + <summary> + Install the default container behavior into the container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultBehaviorExtension.Remove"> + <summary> + Remove the default behavior from the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.UnityDefaultStrategiesExtension"> + <summary> + This extension installs the default strategies and policies into the container + to implement the standard behavior of the Unity container. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.UnityDefaultStrategiesExtension.Initialize"> + <summary> + Add the default ObjectBuilder strategies & policies to the container. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Guard"> + <summary> + A static helper class that includes various parameter checking routines. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(System.Object,System.String)"> + <summary> + Throws <see cref="T:System.ArgumentNullException"/> if the given argument is null. + </summary> + <exception cref="T:System.ArgumentNullException"> if tested value if null.</exception> + <param name="argumentValue">Argument value to test.</param> + <param name="argumentName">Name of the argument being tested.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNullOrEmpty(System.String,System.String)"> + <summary> + Throws an exception if the tested string argument is null or the empty string. + </summary> + <exception cref="T:System.ArgumentNullException">Thrown if string value is null.</exception> + <exception cref="T:System.ArgumentException">Thrown if the string is empty</exception> + <param name="argumentValue">Argument value to check.</param> + <param name="argumentName">Name of argument being checked.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.TypeIsAssignable(System.Type,System.Type,System.String)"> + <summary> + Verifies that an argument type is assignable from the provided type (meaning + interfaces are implemented, or classes exist in the base class hierarchy). + </summary> + <param name="assignmentTargetType">The argument type that will be assigned to.</param> + <param name="assignmentValueType">The type of the value being assigned.</param> + <param name="argumentName">Argument name.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Guard.InstanceIsAssignable(System.Type,System.Object,System.String)"> + <summary> + Verifies that an argument instance is assignable from the provided type (meaning + interfaces are implemented, or classes exist in the base class hierarchy, or instance can be + assigned through a runtime wrapper, as is the case for COM Objects). + </summary> + <param name="assignmentTargetType">The argument type that will be assigned to.</param> + <param name="assignmentInstance">The instance that will be assigned.</param> + <param name="argumentName">Argument name.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.MethodReflectionHelper"> + <summary> + Helper class to wrap common reflection stuff dealing with + methods. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.#ctor(System.Reflection.MethodBase)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.MethodReflectionHelper"/> instance that + lets us do more reflection stuff on that method. + </summary> + <param name="method">The method to reflect on.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.GetClosedParameterTypes(System.Type[])"> + <summary> + Given our set of generic type arguments, + </summary> + <param name="genericTypeArguments">The generic type arguments.</param> + <returns>An array with closed parameter types. </returns> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.MethodHasOpenGenericParameters"> + <summary> + Returns true if any of the parameters of this method + are open generics. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.MethodReflectionHelper.ParameterTypes"> + <summary> + Return the <see cref="T:System.Type"/> of each parameter for this + method. + </summary> + <returns>Sequence of <see cref="T:System.Type"/> objects, one for + each parameter in order.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Pair`2"> + <summary> + A helper class that encapsulates two different + data items together into a a single item. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Pair`2.#ctor(`0,`1)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.Pair`2"/> containing + the two values give. + </summary> + <param name="first">First value</param> + <param name="second">Second value</param> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.Pair`2.First"> + <summary> + The first value of the pair. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.Pair`2.Second"> + <summary> + The second value of the pair. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.Pair"> + <summary> + Container for a Pair helper method. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.Pair.Make``2(``0,``1)"> + <summary> + A helper factory method that lets users take advantage of type inference. + </summary> + <typeparam name="TFirstParameter">Type of first value.</typeparam> + <typeparam name="TSecondParameter">Type of second value.</typeparam> + <param name="first">First value.</param> + <param name="second">Second value.</param> + <returns>A new <see cref="T:Microsoft.Practices.Unity.Utility.Pair`2"/> instance.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ParameterMatcher"> + <summary> + A utility class that handles the logic of matching parameter + lists, so we can find the right constructor and method overloads. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.#ctor(System.Collections.Generic.IEnumerable{Microsoft.Practices.Unity.InjectionParameterValue})"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.ParameterMatcher"/> that will attempt to + match the given parameter types. + </summary> + <param name="parametersToMatch">Target parameters to match against.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.Matches(System.Collections.Generic.IEnumerable{System.Type})"> + <summary> + Tests to see if the given set of types matches the ones + we're looking for. + </summary> + <param name="candidate">parameter list to look for.</param> + <returns>true if they match, false if they don't.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterMatcher.Matches(System.Collections.Generic.IEnumerable{System.Reflection.ParameterInfo})"> + <summary> + Tests to see if the given set of types matches the ones we're looking for. + </summary> + <param name="candidate">Candidate method signature to look for.</param> + <returns>True if they match, false if they don't.</returns> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper"> + <summary> + Another reflection helper class that has extra methods + for dealing with ParameterInfos. + </summary> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.ReflectionHelper"> + <summary> + A small helper class to encapsulate details of the + reflection API, particularly around generics. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.#ctor(System.Type)"> + <summary> + Create a new <see cref="T:Microsoft.Practices.Unity.Utility.ReflectionHelper"/> instance that + lets you look at information about the given type. + </summary> + <param name="typeToReflect">Type to do reflection on.</param> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.MethodHasOpenGenericParameters(System.Reflection.MethodBase)"> + <summary> + Test the given <see cref="T:System.Reflection.MethodBase"/> object, looking at + the parameters. Determine if any of the parameters are + open generic types that need type attributes filled in. + </summary> + <param name="method">The method to check.</param> + <returns>True if any of the parameters are open generics. False if not.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.GetClosedParameterType(System.Type[])"> + <summary> + If this type is an open generic, use the + given <paramref name="genericArguments"/> array to + determine what the required closed type is and return that. + </summary> + <remarks>If the parameter is not an open type, just + return this parameter's type.</remarks> + <param name="genericArguments">Type arguments to substitute in for + the open type parameters.</param> + <returns>Corresponding closed type of this parameter.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ReflectionHelper.GetNamedGenericParameter(System.String)"> + <summary> + Given a generic argument name, return the corresponding type for this + closed type. For example, if the current type is SomeType<User>, and the + corresponding definition was SomeType<TSomething>, calling this method + and passing "TSomething" will return typeof(User). + </summary> + <param name="parameterName">Name of the generic parameter.</param> + <returns>Type of the corresponding generic parameter, or null if there + is no matching name.</returns> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"> + <summary> + The <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/> object we're reflecting over. + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsGenericType"> + <summary> + Is this type generic? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsOpenGeneric"> + <summary> + Is this type an open generic (no type parameter specified) + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsArray"> + <summary> + Is this type an array type? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.IsGenericArray"> + <summary> + Is this type an array of generic elements? + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.ArrayElementType"> + <summary> + The type of the elements in this type (if it's an array). + </summary> + </member> + <member name="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.InstanceConstructors"> + <summary> + Returns all the public constructors defined for the current reflected <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/>. + </summary> + <value> + An enumeration of <see cref="T:System.Reflection.ConstructorInfo"/> ConstructorInfo objects representing all the public instance constructors defined for the + current reflected <see cref="P:Microsoft.Practices.Unity.Utility.ReflectionHelper.Type"/>, but not including the type initializer (static constructor). + </value> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper.#ctor(System.Reflection.ParameterInfo)"> + <summary> + Create a new instance of <see cref="T:Microsoft.Practices.Unity.Utility.ParameterReflectionHelper"/> that + lets you query information about the given ParameterInfo object. + </summary> + <param name="parameter">Parameter to query.</param> + </member> + <member name="T:Microsoft.Practices.Unity.Utility.StaticReflection"> + <summary> + A set of helper methods to pick through lambdas and pull out + <see cref="T:System.Reflection.MethodInfo"/> from them. + </summary> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMethodInfo(System.Linq.Expressions.Expression{System.Action})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object from an expression of the form + () => SomeClass.SomeMethod() + </summary> + <param name="expression">Expression describing the method to call.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMethodInfo``1(System.Linq.Expressions.Expression{System.Action{``0}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object from an expression of the form + x => x.SomeMethod() + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <param name="expression">Expression describing the method to call.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetPropertyGetMethodInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object for the get method from an expression of the form + x => x.SomeProperty + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <typeparam name="TProperty">The type for the property.</typeparam> + <param name="expression">Expression describing the property for which the get method is to be extracted.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetPropertySetMethodInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + Pull out a <see cref="T:System.Reflection.MethodInfo"/> object for the set method from an expression of the form + x => x.SomeProperty + </summary> + <typeparam name="T">The type where the method is defined.</typeparam> + <typeparam name="TProperty">The type for the property.</typeparam> + <param name="expression">Expression describing the property for which the set method is to be extracted.</param> + <returns>Corresponding <see cref="T:System.Reflection.MethodInfo"/>.</returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetMemberInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> + <summary> + + </summary> + <typeparam name="T"></typeparam> + <typeparam name="TProperty"></typeparam> + <param name="expression"></param> + <returns></returns> + </member> + <member name="M:Microsoft.Practices.Unity.Utility.StaticReflection.GetConstructorInfo``1(System.Linq.Expressions.Expression{System.Func{``0}})"> + <summary> + Pull out a <see cref="T:System.Reflection.ConstructorInfo"/> object from an expression of the form () => new SomeType() + </summary> + <typeparam name="T">The type where the constructor is defined.</typeparam> + <param name="expression">Expression invoking the desired constructor.</param> + <returns>Corresponding <see cref="T:System.Reflection.ConstructorInfo"/>.</returns> + </member> + </members> +</doc>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/Unity.3.0.1304.1/tools/install.ps1 Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,3 @@ +param($installPath, $toolsPath, $package, $project) + +$project.DTE.ItemOperations.Navigate('https://unity.codeplex.com/wikipage?title=Unity3ReleaseNotes') \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/packages/repositories.config Sun Aug 24 11:14:55 2014 +0400 @@ -0,0 +1,5 @@ +<?xml version="1.0" encoding="utf-8"?> +<repositories> + <repository path="..\Core\RazorEngine.Core\packages.config" /> + <repository path="..\Core\Tests\RazorEngine.Core.Tests\packages.config" /> +</repositories> \ No newline at end of file