Releasing 0.15.1

[csharpfritz]

No description provided.

To fix the problem, remove the redundant null-conditional access on ParentMenu inside the if block that is already guarded by ParentMenu?.RenderingMode == MenuRenderingMode.Table. Once we are inside that if, ParentMenu is known to be non‑null whenever the block executes, so subsequent uses can safely reference ParentMenu directly. This simplifies the condition and removes the constant-condition warning without changing functionality.

Concretely, in src/BlazorWebFormsComponents/MenuItem.razor, on line 5 change ParentMenu?.Orientation to ParentMenu.Orientation. No other changes are required, and no new imports or methods are needed. All other uses of ParentMenu?. occur outside the guarded block or form part of public API-style checks and should remain as-is.

In general, to fix a useless type test where a variable’s static type is already known to implement an interface, you remove the is/as check and either rely on compile-time typing or use members of the interface directly. For a unit test whose only purpose is to assert the type relationship, you can instead assert the presence or behavior of members that the interface is expected to provide.

For this specific code, menu is obtained via cut.FindComponent<Menu>().Instance, so its static type is Menu. Since Menu is always an IMenuStyleContainer, the expression (menu is BlazorWebFormsComponents.Interfaces.IMenuStyleContainer) is a redundant runtime test. The test’s intent is to ensure that Menu provides menu-style container behavior. We can keep that intent without the useless type test by asserting on a member expected from IMenuStyleContainer that we already use elsewhere in this file—namely StaticMenuStyle. A simple, non-redundant check is to assert that menu.StaticMenuStyle is not null, which demonstrates that the “menu style container” capability is present.

Concretely, in src/BlazorWebFormsComponents.Test/Menu/MenuLevelStyles.razor, within the Menu_ImplementsIMenuStyleContainer test, replace line 176 to assert that menu.StaticMenuStyle is not null instead of asserting the is relationship. No new imports are required because ShouldBeTrue is already used elsewhere and ShouldNotBeNull is already used in the Menu_StaticMenuStyle_DefaultIsNotNull test below, so the assertion library is available.

To fix the issue, make the field ref2 a readonly field so that its reference cannot be changed after initialization. This aligns with how the field is used: it's created once and then only consumed. To keep the code consistent and avoid similar warnings for the other analogous fields, we should also mark ref1, ref3, and ref4 as readonly, as they share the same initialization and usage pattern.

Concretely, in src/BlazorWebFormsComponents.Test/Validations/ValidationSummary/CommaSplitTests.razor, at the bottom of the @code block, update the four ForwardRef<InputBase<string>> field declarations (lines 90, 94, 98, and 102) to include the readonly modifier. No new imports or methods are required; this is purely a modifier change on existing field declarations.

To fix the problem, add the readonly modifier to the model1 field so it cannot be reassigned after construction/initialization, while still allowing mutation of the object it references (e.g., changing Name), which is not restricted by readonly. This aligns with the rule’s recommendation and does not change existing functionality because the tests only pass model1 into components and do not reassign it.

Concretely, in src/BlazorWebFormsComponents.Test/Validations/ValidationSummary/CommaSplitTests.razor, at the bottom of the file where the fields are declared, update the model1 declaration on line 91 from private ExModel model1 = new ExModel(); to private readonly ExModel model1 = new ExModel();. The rest of the fields (model2, model3, model4, and the ForwardRef and _invalid flags) are not mentioned by CodeQL here, and we have no instruction to change them, so they should remain as-is. No new imports or method changes are needed; readonly is a standard C# modifier and does not require extra dependencies.

In general, to fix a "Missed 'readonly' opportunity" issue, you add the readonly modifier to fields that are only assigned at declaration or within constructors of the same class. This prevents later unintended reassignment of the field reference while allowing mutation of the object the field points to.

For this file, the best fix is to mark the ForwardRef<InputBase<string>> fields (ref1, ref2, ref3, and ref4) as readonly. They are initialized once at their declarations and never reassigned in the snippet; they are simply used in the markup to refer to input components and validators. Adding readonly will not affect how Blazor uses the ForwardRef instance, since Blazor mutates the Current property of the ForwardRef object rather than reassigning the field variable.

Concretely:

• In src/BlazorWebFormsComponents.Test/Validations/ValidationSummary/CommaSplitTests.razor, on the four lines where ref1, ref2, ref3, and ref4 are declared, change ForwardRef<InputBase<string>> refX = ...; to private readonly ForwardRef<InputBase<string>> refX = ...;.
• No new imports, methods, or other definitions are required; this is a pure modifier change on existing fields.

In general, to fix a “Missed readonly opportunity” issue, add the readonly modifier to any field that is fully assigned either at its declaration or within a constructor in the same class and never reassigned elsewhere. This prevents unintended reassignment of the field reference while still allowing mutation of the referenced object’s internal state if it is a reference type.

For this specific case, we should add readonly to the model4 field declaration on line 103: change private ExModel model4 = new ExModel(); to private readonly ExModel model4 = new ExModel();. This preserves all existing functionality: the EditForm continues to bind to model4, and the Name property can still change via user input; only reassignment of the model4 field itself becomes disallowed. No additional imports, methods, or other definitions are required, and no other lines in this file need modification.

To fix the issue, the field ref4 should be declared with the readonly modifier since it is only assigned at declaration. This prevents unintended reassignment after object initialization while preserving current behavior.

Concretely, in src/BlazorWebFormsComponents.Test/Validations/ValidationSummary/CommaSplitTests.razor, locate the field declaration near the bottom:

ForwardRef<InputBase<string>> ref4 = new ForwardRef<InputBase<string>>();

and add the readonly modifier:

private readonly ForwardRef<InputBase<string>> ref4 = new ForwardRef<InputBase<string>>();

This aligns ref4 with the CodeQL recommendation without changing any test logic. No additional methods, imports, or definitions are needed, and no other code regions need modification based on the information provided.

To fix the problem in general, mark any field as readonly when it is only assigned at declaration or within constructors of the same class, and never reassigned elsewhere. This constrains the field reference to be immutable after construction while still allowing mutation of the object’s internal state.

In this specific file, the best fix without changing functionality is to add the readonly modifier to model3 (and, by the same reasoning, to the other model fields model1, model2, and model4 if they are similarly flagged). Each of these fields is initialized once with new ExModel() and then used as the model for the corresponding EditForm. Changing them to private readonly ExModel modelX = new ExModel(); does not affect the tests because the code never reassigns the fields; only the Name property is mutated through binding. No new imports or helper methods are required; only the field declarations at the bottom of the @code block need their modifiers updated.

Concretely, in src/BlazorWebFormsComponents.Test/Validations/ValidationSummary/CommaSplitTests.razor, update the declarations on lines 91, 95, 99, and 103 so each private ExModel modelN = new ExModel(); becomes private readonly ExModel modelN = new ExModel();.

In general, to fix a "Missed 'readonly' opportunity" for a field, you add the readonly modifier to the field declaration when the field is only assigned at declaration time and/or in the class’s constructors. This ensures that the field reference cannot be changed after object initialization, while leaving the object it refers to free to mutate as normal.

For this specific case in src/BlazorWebFormsComponents.Test/Validations/ValidationSummary/CommaSplitTests.razor, we should update the declaration of ref3 (and only ref3, as requested) to add the readonly modifier. The original line:

ForwardRef<InputBase<string>> ref3 = new ForwardRef<InputBase<string>>();

should become:

private readonly ForwardRef<InputBase<string>> ref3 = new ForwardRef<InputBase<string>>();

This preserves the existing initialization and type, simply constraining the field so that it cannot be reassigned later. No new imports, helper methods, or other structural changes are required, and no other fields need to be modified for this particular CodeQL finding.

In general, to fix a “Missed 'readonly' opportunity” for a field, you add the readonly modifier to the field declaration, provided that the field is only ever assigned at its declaration or within constructors of the same class. This prevents later unintended reassignment of the field while still allowing mutation of the object it references (if it’s a reference type).

For this specific case, the best fix is to add the readonly modifier to the model2 field declaration on line 95 of CommaSplitTests.razor, changing private ExModel model2 = new ExModel(); to private readonly ExModel model2 = new ExModel();. This does not change any existing behavior: the tests and bindings will continue to work because they mutate model2’s properties, not the field reference. No new methods or imports are required, and no other lines need to be edited.