diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..75821666 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,275 @@ +# EditorConfig is awesome: https://EditorConfig.org + +# top-most EditorConfig file +root = true + +# Don't use tabs for indentation. +[*] +indent_style = space +# (Please don't specify an indent_size here; that has too many unintended consequences.) + +# Code files +[*.{cs,csx,vb,vbx}] +indent_size = 4 +insert_final_newline = true + +# XML project files +[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}] +indent_size = 2 + +# XML config files +[*.{props,targets,ruleset,config,nuspec,resx,vsixmanifest,vsct}] +indent_size = 2 + +# Powershell files +[*.ps1] +indent_size = 2 + +# Shell script files +[*.sh] +end_of_line = lf +indent_size = 2 + +# Dotnet code style settings: +[*.{cs,vb}] + +# IDE0055: Fix formatting +dotnet_diagnostic.IDE0055.severity = warning + +# Sort using and Import directives with System.* appearing first +dotnet_sort_system_directives_first = true +dotnet_separate_import_directive_groups = false +# Avoid "this." and "Me." if not necessary +dotnet_style_qualification_for_field = false:refactoring +dotnet_style_qualification_for_property = false:refactoring +dotnet_style_qualification_for_method = false:refactoring +dotnet_style_qualification_for_event = false:refactoring + +# Use language keywords instead of framework type names for type references +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion + +# Suggest more modern language features when available +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_explicit_tuple_names = true:suggestion + +# Whitespace options +dotnet_style_allow_multiple_blank_lines_experimental = false + +# Constants are PascalCase +dotnet_naming_rule.constants_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.constants_should_be_pascal_case.symbols = constants +dotnet_naming_rule.constants_should_be_pascal_case.style = constant_style + +dotnet_naming_symbols.constants.applicable_kinds = field, local +dotnet_naming_symbols.constants.required_modifiers = const + +dotnet_naming_style.constant_style.capitalization = pascal_case + +# Static fields are camelCase and start with s_ +dotnet_naming_rule.static_fields_should_be_camel_case.severity = suggestion +dotnet_naming_rule.static_fields_should_be_camel_case.symbols = static_fields +dotnet_naming_rule.static_fields_should_be_camel_case.style = static_field_style + +dotnet_naming_symbols.static_fields.applicable_kinds = field +dotnet_naming_symbols.static_fields.required_modifiers = static + +dotnet_naming_style.static_field_style.capitalization = camel_case +dotnet_naming_style.static_field_style.required_prefix = s_ + +# Instance fields are camelCase and start with _ +dotnet_naming_rule.instance_fields_should_be_camel_case.severity = suggestion +dotnet_naming_rule.instance_fields_should_be_camel_case.symbols = instance_fields +dotnet_naming_rule.instance_fields_should_be_camel_case.style = instance_field_style + +dotnet_naming_symbols.instance_fields.applicable_kinds = field + +dotnet_naming_style.instance_field_style.capitalization = camel_case +dotnet_naming_style.instance_field_style.required_prefix = _ + +# Locals and parameters are camelCase +dotnet_naming_rule.locals_should_be_camel_case.severity = suggestion +dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters +dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style + +dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local + +dotnet_naming_style.camel_case_style.capitalization = camel_case + +# Local functions are PascalCase +dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions +dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style + +dotnet_naming_symbols.local_functions.applicable_kinds = local_function + +dotnet_naming_style.local_function_style.capitalization = pascal_case + +# By default, name items with PascalCase +dotnet_naming_rule.members_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.members_should_be_pascal_case.symbols = all_members +dotnet_naming_rule.members_should_be_pascal_case.style = pascal_case_style + +dotnet_naming_symbols.all_members.applicable_kinds = * + +dotnet_naming_style.pascal_case_style.capitalization = pascal_case + +# error RS2008: Enable analyzer release tracking for the analyzer project containing rule '{0}' +dotnet_diagnostic.RS2008.severity = none + +# IDE0035: Remove unreachable code +dotnet_diagnostic.IDE0035.severity = warning + +# IDE0036: Order modifiers +dotnet_diagnostic.IDE0036.severity = warning + +# IDE0043: Format string contains invalid placeholder +dotnet_diagnostic.IDE0043.severity = warning + +# IDE0044: Make field readonly +dotnet_diagnostic.IDE0044.severity = warning + +# RS0016: Only enable if API files are present +dotnet_public_api_analyzer.require_api_files = true + +# CSharp code style settings: +[*.cs] +# Newline settings +csharp_new_line_before_open_brace = all +csharp_new_line_before_else = true +csharp_new_line_before_catch = true +csharp_new_line_before_finally = true +csharp_new_line_before_members_in_object_initializers = true +csharp_new_line_before_members_in_anonymous_types = true +csharp_new_line_between_query_expression_clauses = true + +# Indentation preferences +csharp_indent_block_contents = true +csharp_indent_braces = false +csharp_indent_case_contents = true +csharp_indent_case_contents_when_block = true +csharp_indent_switch_labels = true +csharp_indent_labels = flush_left + +# Whitespace options +csharp_style_allow_embedded_statements_on_same_line_experimental = false +csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false +csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = false + +# Prefer "var" everywhere +csharp_style_var_for_built_in_types = true:suggestion +csharp_style_var_when_type_is_apparent = true:suggestion +csharp_style_var_elsewhere = true:suggestion + +# Prefer method-like constructs to have a block body +csharp_style_expression_bodied_methods = false:none +csharp_style_expression_bodied_constructors = false:none +csharp_style_expression_bodied_operators = false:none + +# Prefer property-like constructs to have an expression-body +csharp_style_expression_bodied_properties = true:none +csharp_style_expression_bodied_indexers = true:none +csharp_style_expression_bodied_accessors = true:none + +# Suggest more modern language features when available +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion +csharp_style_throw_expression = true:suggestion +csharp_style_conditional_delegate_call = true:suggestion + +# Space preferences +csharp_space_after_cast = true +csharp_space_after_colon_in_inheritance_clause = true +csharp_space_after_comma = true +csharp_space_after_dot = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_after_semicolon_in_for_statement = true +csharp_space_around_binary_operators = before_and_after +csharp_space_around_declaration_statements = do_not_ignore +csharp_space_before_colon_in_inheritance_clause = true +csharp_space_before_comma = false +csharp_space_before_dot = false +csharp_space_before_open_square_brackets = false +csharp_space_before_semicolon_in_for_statement = false +csharp_space_between_empty_square_brackets = false +csharp_space_between_method_call_empty_parameter_list_parentheses = false +csharp_space_between_method_call_name_and_opening_parenthesis = false +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_between_method_declaration_empty_parameter_list_parentheses = false +csharp_space_between_method_declaration_name_and_open_parenthesis = false +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_parentheses = false +csharp_space_between_square_brackets = false + +# Blocks are allowed +csharp_prefer_braces = true:silent +csharp_preserve_single_line_blocks = true +csharp_preserve_single_line_statements = true + +# Currently only enabled for C# due to crash in VB analyzer. VB can be enabled once +# https://github.com/dotnet/roslyn/pull/54259 has been published. +dotnet_style_allow_statement_immediately_after_block_experimental = false + +[src/CodeStyle/**.{cs,vb}] +# warning RS0005: Do not use generic CodeAction.Create to create CodeAction +dotnet_diagnostic.RS0005.severity = none + +[src/{Analyzers,CodeStyle,Features,Workspaces,EditorFeatures,VisualStudio}/**/*.{cs,vb}] + +# IDE0011: Add braces +csharp_prefer_braces = when_multiline:warning +# NOTE: We need the below severity entry for Add Braces due to https://github.com/dotnet/roslyn/issues/44201 +dotnet_diagnostic.IDE0011.severity = warning + +# IDE0040: Add accessibility modifiers +dotnet_diagnostic.IDE0040.severity = warning + +# CONSIDER: Are IDE0051 and IDE0052 too noisy to be warnings for IDE editing scenarios? Should they be made build-only warnings? +# IDE0051: Remove unused private member +dotnet_diagnostic.IDE0051.severity = warning + +# IDE0052: Remove unread private member +dotnet_diagnostic.IDE0052.severity = warning + +# IDE0059: Unnecessary assignment to a value +dotnet_diagnostic.IDE0059.severity = warning + +# IDE0060: Remove unused parameter +dotnet_diagnostic.IDE0060.severity = warning + +# CA1012: Abstract types should not have public constructors +dotnet_diagnostic.CA1012.severity = warning + +# CA1822: Make member static +dotnet_diagnostic.CA1822.severity = warning + +# Prefer "var" everywhere +dotnet_diagnostic.IDE0007.severity = warning +csharp_style_var_for_built_in_types = true:warning +csharp_style_var_when_type_is_apparent = true:warning +csharp_style_var_elsewhere = true:warning + +# dotnet_style_allow_multiple_blank_lines_experimental +dotnet_diagnostic.IDE2000.severity = warning + +# csharp_style_allow_embedded_statements_on_same_line_experimental +dotnet_diagnostic.IDE2001.severity = warning + +# csharp_style_allow_blank_lines_between_consecutive_braces_experimental +dotnet_diagnostic.IDE2002.severity = warning + +# dotnet_style_allow_statement_immediately_after_block_experimental +dotnet_diagnostic.IDE2003.severity = warning + +# csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental +dotnet_diagnostic.IDE2004.severity = warning + +[src/{VisualStudio}/**/*.{cs,vb}] +# CA1822: Make member static +# Not enforced as a build 'warning' for 'VisualStudio' layer due to large number of false positives from https://github.com/dotnet/roslyn-analyzers/issues/3857 and https://github.com/dotnet/roslyn-analyzers/issues/3858 +# Additionally, there is a risk of accidentally breaking an internal API that partners rely on though IVT. +dotnet_diagnostic.CA1822.severity = suggestion diff --git a/src/Spring/Spring.Core/Expressions/ReferenceNode.cs b/src/Spring/Spring.Core/Expressions/ReferenceNode.cs index 971be72c..9bc3788a 100644 --- a/src/Spring/Spring.Core/Expressions/ReferenceNode.cs +++ b/src/Spring/Spring.Core/Expressions/ReferenceNode.cs @@ -1,7 +1,7 @@ #region License /* - * Copyright © 2002-2011 the original author or authors. + * Copyright � 2002-2011 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,73 +25,75 @@ using System.Runtime.Serialization; namespace Spring.Context.Support { - /// - /// Represents a reference to a Spring-managed object. - /// - /// Aleksandar Seovic - [Serializable] - public class ReferenceNode : BaseNode - { - /// - /// Create a new instance - /// - public ReferenceNode() { } + /// + /// Represents a reference to a Spring-managed object. + /// + /// Aleksandar Seovic + [Serializable] + public class ReferenceNode : BaseNode + { + /// + /// Create a new instance + /// + public ReferenceNode() { } - /// - /// Create a new instance from SerializationInfo - /// - protected ReferenceNode(SerializationInfo info, StreamingContext context) - : base(info, context) { } + /// + /// Create a new instance from SerializationInfo + /// + protected ReferenceNode(SerializationInfo info, StreamingContext context) + : base(info, context) + { + } - /// - /// - /// Returns a value for the integer literal node. - /// - /// Context to evaluate expressions against. - /// Current expression evaluation context. - /// Node's value. - protected override object Get(object context, EvaluationContext evalContext) - { - var objectName = ResolveNames(out var contextName); + /// + /// + /// Returns a value for the integer literal node. + /// + /// Context to evaluate expressions against. + /// Current expression evaluation context. + /// Node's value. + protected override object Get(object context, EvaluationContext evalContext) + { + var objectName = ResolveNames(out var contextName); - var sourceContext = SelectSourceContext(evalContext, contextName); + var sourceContext = SelectSourceContext(evalContext, contextName); - return sourceContext.GetObject(objectName); - } + return sourceContext.GetObject(objectName); + } - private string ResolveNames(out string contextName) - { - var hasContextDefined = getNumberOfChildren() == 2; + private string ResolveNames(out string contextName) + { + var hasContextDefined = getNumberOfChildren() == 2; - if (hasContextDefined) - { - contextName = getFirstChild().getText(); - return getFirstChild().getNextSibling().getText(); - } + if (hasContextDefined) + { + contextName = getFirstChild().getText(); + return getFirstChild().getNextSibling().getText(); + } - contextName = null; - return getFirstChild().getText(); - } + contextName = null; + return getFirstChild().getText(); + } - private static IObjectFactory SelectSourceContext(EvaluationContext evalContext, string contextName) - { - if (contextName != null) - return ContextRegistry.GetContext(contextName) ?? throw new ArgumentException($"Context '{contextName}' is not registered."); + private static IObjectFactory SelectSourceContext(EvaluationContext evalContext, string contextName) + { + if (contextName != null) + return ContextRegistry.GetContext(contextName) ?? throw new ArgumentException($"Context '{contextName}' is not registered."); - if (TryGetFromCurrentContext(evalContext, out var currentObjectFactory)) - return (IObjectFactory)currentObjectFactory; + if (TryGetFromCurrentContext(evalContext, out var currentObjectFactory)) + return (IObjectFactory) currentObjectFactory; - return ContextRegistry.GetContext() ?? throw new ArgumentException("No context registered."); - } + return ContextRegistry.GetContext() ?? throw new ArgumentException("No context registered."); + } - private static bool TryGetFromCurrentContext(EvaluationContext evalContext, out object currentObjectFactory) - { - currentObjectFactory = null; + private static bool TryGetFromCurrentContext(EvaluationContext evalContext, out object currentObjectFactory) + { + currentObjectFactory = null; - if (evalContext.Variables is null) - return false; + if (evalContext.Variables is null) + return false; - return evalContext.Variables.TryGetValue(Expression.ReservedVariableNames.CurrentObjectFactory, out currentObjectFactory); - } - } -} \ No newline at end of file + return evalContext.Variables.TryGetValue(Expression.ReservedVariableNames.CurrentObjectFactory, out currentObjectFactory); + } + } +} diff --git a/test/Spring/Spring.Core.Tests/Expressions/ReferenceNodeTests.cs b/test/Spring/Spring.Core.Tests/Expressions/ReferenceNodeTests.cs index 39cfe1eb..96f502ed 100644 --- a/test/Spring/Spring.Core.Tests/Expressions/ReferenceNodeTests.cs +++ b/test/Spring/Spring.Core.Tests/Expressions/ReferenceNodeTests.cs @@ -1,7 +1,7 @@ #region License /* - * Copyright © 2002-2011 the original author or authors. + * Copyright � 2002-2011 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,10 +18,7 @@ #endregion -#region Imports - using System; - using NUnit.Framework; using Spring.Context; using Spring.Context.Support; @@ -30,168 +27,160 @@ using Spring.Objects.Factory.Xml; using System.Collections.Generic; using System.Text; -#endregion - namespace Spring.Expressions { - /// - /// - /// - /// Erich Eichinger - [TestFixture] - public class ReferenceNodeTests - { - private class MyTestObject - { - public object MyField { get; set; } - } + /// + /// + /// + /// Erich Eichinger + [TestFixture] + public class ReferenceNodeTests + { + private class MyTestObject + { + public object MyField { get; set; } + } - [TearDown] - public void TearDown() => ContextRegistry.Clear(); + [TearDown] + public void TearDown() => ContextRegistry.Clear(); - [Test] - public void DoesNotCallContextRegistryForLocalObjectFactoryReferences() - { - var xml = $@" + [Test] + public void DoesNotCallContextRegistryForLocalObjectFactoryReferences() + { + var xml = $@" "; - var objectFactory = new XmlObjectFactory(new StringResource(xml, Encoding.UTF8)); - var theObject = new object(); - objectFactory.RegisterSingleton("theObject", theObject); + var objectFactory = new XmlObjectFactory(new StringResource(xml, Encoding.UTF8)); + var theObject = new object(); + objectFactory.RegisterSingleton("theObject", theObject); - var to = (MyTestObject)objectFactory.GetObject("foo"); - Assert.That(theObject, Is.SameAs(to.MyField)); - } + var to = (MyTestObject) objectFactory.GetObject("foo"); + Assert.That(theObject, Is.SameAs(to.MyField)); + } - [Test] - public void UseDefaultContextRegistryWhenNoContextProvided() - { - var defaultXml = $@" + [Test] + public void UseDefaultContextRegistryWhenNoContextProvided() + { + var defaultXml = $@" "; - var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); - ContextRegistry.RegisterContext(defaultContext); + var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); + ContextRegistry.RegisterContext(defaultContext); - var expectedObject = defaultContext.GetObject("theObject"); + var expectedObject = defaultContext.GetObject("theObject"); - var expression = Expression.Parse("@(theObject)"); - var value = expression.GetValue(null, new Dictionary()); + var expression = Expression.Parse("@(theObject)"); + var value = expression.GetValue(null, new Dictionary()); - Assert.That(value, Is.SameAs(expectedObject)); - } + Assert.That(value, Is.SameAs(expectedObject)); + } - [Test] - public void ThrowsApplicationContextException_WhenContextNotRegistered() - { - var defaultXml = $@" + [Test] + public void ThrowsApplicationContextException_WhenContextNotRegistered() + { + var defaultXml = $@" "; - var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); - ContextRegistry.RegisterContext(defaultContext); + var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); + ContextRegistry.RegisterContext(defaultContext); - var expression = Expression.Parse("@(anotherContext:theObject).Value"); - void Get() => expression.GetValue(null, new Dictionary()); + var expression = Expression.Parse("@(anotherContext:theObject).Value"); + void Get() => expression.GetValue(null, new Dictionary()); - Assert.That(Get, Throws.InstanceOf()); - } + Assert.That(Get, Throws.InstanceOf()); + } - [Test] - public void WhenContextNameSpecifiedInExpression_UseThatContext() - { - const string anotherContextName = "AnotherContext"; + [Test] + public void WhenContextNameSpecifiedInExpression_UseThatContext() + { + const string anotherContextName = "AnotherContext"; - var defaultXml = $@" + var defaultXml = $@" "; - var anotherXml = $@" + var anotherXml = $@" "; - var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); - ContextRegistry.RegisterContext(defaultContext); + var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); + ContextRegistry.RegisterContext(defaultContext); - var anotherContext = GetContextFromXmlString(anotherXml, anotherContextName); - ContextRegistry.RegisterContext(anotherContext); + var anotherContext = GetContextFromXmlString(anotherXml, anotherContextName); + ContextRegistry.RegisterContext(anotherContext); - var expectedObject = anotherContext.GetObject("theObject"); + var expectedObject = anotherContext.GetObject("theObject"); - var expression = Expression.Parse($"@({anotherContextName}:theObject)"); - var resolvedObject = expression.GetValue(null, new Dictionary()); + var expression = Expression.Parse($"@({anotherContextName}:theObject)"); + var resolvedObject = expression.GetValue(null, new Dictionary()); - Assert.That(resolvedObject, Is.SameAs(expectedObject)); - } + Assert.That(resolvedObject, Is.SameAs(expectedObject)); + } - [Test] - public void UseObjectFactoryFromVariables() - { - const string anotherContextName = "AnotherContext"; + [Test] + public void UseObjectFactoryFromVariables() + { + const string anotherContextName = "AnotherContext"; - var defaultXml = $@" + var defaultXml = $@" "; - var anotherXml = $@" + var anotherXml = $@" "; - var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); - ContextRegistry.RegisterContext(defaultContext); + var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); + ContextRegistry.RegisterContext(defaultContext); - var anotherContext = GetContextFromXmlString(anotherXml, anotherContextName); - var variables = new Dictionary - { - [Expression.ReservedVariableNames.RESERVEDPREFIX + "CurrentObjectFactory"] = anotherContext.ObjectFactory - }; - var expectedObject = anotherContext.GetObject("theObject"); + var anotherContext = GetContextFromXmlString(anotherXml, anotherContextName); + var variables = new Dictionary { [Expression.ReservedVariableNames.RESERVEDPREFIX + "CurrentObjectFactory"] = anotherContext.ObjectFactory }; + var expectedObject = anotherContext.GetObject("theObject"); - var expression = Expression.Parse("@(theObject)"); - var resolvedObject = expression.GetValue(null, variables); + var expression = Expression.Parse("@(theObject)"); + var resolvedObject = expression.GetValue(null, variables); - Assert.That(resolvedObject, Is.SameAs(expectedObject)); - } + Assert.That(resolvedObject, Is.SameAs(expectedObject)); + } - [Test] - public void ShouldThrowException_WhenFactoryProvidedInVariables_IsNotOfTypeIObjectFactory() - { - var defaultXml = $@" + [Test] + public void ShouldThrowException_WhenFactoryProvidedInVariables_IsNotOfTypeIObjectFactory() + { + var defaultXml = $@" "; - var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); - ContextRegistry.RegisterContext(defaultContext); + var defaultContext = GetContextFromXmlString(defaultXml, AbstractApplicationContext.DefaultRootContextName); + ContextRegistry.RegisterContext(defaultContext); - var variables = new Dictionary - { - [Expression.ReservedVariableNames.RESERVEDPREFIX + "CurrentObjectFactory"] = new object() - }; + var variables = new Dictionary { [Expression.ReservedVariableNames.RESERVEDPREFIX + "CurrentObjectFactory"] = new object() }; - var expression = Expression.Parse("@(theObject)"); + var expression = Expression.Parse("@(theObject)"); - void Get() => expression.GetValue(null, variables); + void Get() => expression.GetValue(null, variables); - Assert.That(Get, Throws.InstanceOf()); - } + Assert.That(Get, Throws.InstanceOf()); + } - private static GenericApplicationContext GetContextFromXmlString(string xmlString, string contextName) - { - var stringResource = new StringResource(xmlString, Encoding.UTF8); - var objectFactory = new XmlObjectFactory(stringResource); + private static GenericApplicationContext GetContextFromXmlString(string xmlString, string contextName) + { + var stringResource = new StringResource(xmlString, Encoding.UTF8); + var objectFactory = new XmlObjectFactory(stringResource); - return new GenericApplicationContext(objectFactory) { Name = contextName }; - } - } -} \ No newline at end of file + return new GenericApplicationContext(objectFactory) { Name = contextName }; + } + } +}