diff --git a/ChangeLog.md b/ChangeLog.md
index 96e79378b7..1e7d838320 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -24,6 +24,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix analyzer [RCS1253](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1253) ([PR](https://github.com/dotnet/roslynator/pull/1687))
 - Fix refactoring [Check expression for null](https://josefpihrt.github.io/docs/roslynator/refactorings/RR0024) ([PR](https://github.com/dotnet/roslynator/pull/1682))
 
+### Changed
+
+- Change behavior of analyzer [RCS1206](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1206) ([PR](https://github.com/dotnet/roslynator/pull/1685))
+  - The condition for option `omit_when_single_line` will be that the braces/brackets are on the same line, not just the expression in the braces/brackets
+
 ## [4.14.0] - 2025-07-26
 
 ### Added
diff --git a/src/Analyzers/CSharp/Analysis/AddOrRemoveTrailingCommaAnalyzer.cs b/src/Analyzers/CSharp/Analysis/AddOrRemoveTrailingCommaAnalyzer.cs
index 0e39cece2e..8ead2e12f7 100644
--- a/src/Analyzers/CSharp/Analysis/AddOrRemoveTrailingCommaAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analysis/AddOrRemoveTrailingCommaAnalyzer.cs
@@ -69,7 +69,7 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte
                 ReportRemove(context, expressions.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && expressions.IsSingleLine(cancellationToken: context.CancellationToken))
+                && initializer.IsSingleLine(cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, expressions.GetSeparator(count - 1));
             }
@@ -81,7 +81,7 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte
                 ReportAdd(context, expressions.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !expressions.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !initializer.IsSingleLine(cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, expressions.Last());
             }
@@ -104,6 +104,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
 
         int count = members.Count;
         int separatorCount = members.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(enumDeclaration.OpenBraceToken.SpanStart, enumDeclaration.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -112,7 +113,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
                 ReportRemove(context, members.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && members.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(enumDeclaration.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, members.GetSeparator(count - 1));
             }
@@ -124,7 +125,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
                 ReportAdd(context, members.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !members.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(enumDeclaration.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, members.Last());
             }
@@ -147,6 +148,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC
 
         int count = initializers.Count;
         int separatorCount = initializers.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(objectCreation.OpenBraceToken.SpanStart, objectCreation.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -155,7 +157,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC
                 ReportRemove(context, initializers.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && initializers.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(objectCreation.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, initializers.GetSeparator(count - 1));
             }
@@ -167,7 +169,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC
                 ReportAdd(context, initializers.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !initializers.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(objectCreation.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, initializers.Last());
             }
@@ -181,15 +183,16 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)
         if (style == TrailingCommaStyle.None)
             return;
 
-        var objectCreation = (SwitchExpressionSyntax)context.Node;
+        var switchExpression = (SwitchExpressionSyntax)context.Node;
 
-        SeparatedSyntaxList<SwitchExpressionArmSyntax> arms = objectCreation.Arms;
+        SeparatedSyntaxList<SwitchExpressionArmSyntax> arms = switchExpression.Arms;
 
         if (!arms.Any())
             return;
 
         int count = arms.Count;
         int separatorCount = arms.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(switchExpression.OpenBraceToken.SpanStart, switchExpression.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -198,7 +201,7 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)
                 ReportRemove(context, arms.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && arms.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(switchExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, arms.GetSeparator(count - 1));
             }
@@ -210,7 +213,7 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)
                 ReportAdd(context, arms.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !arms.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(switchExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, arms.Last());
             }
@@ -224,15 +227,16 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte
         if (style == TrailingCommaStyle.None)
             return;
 
-        var objectCreation = (PropertyPatternClauseSyntax)context.Node;
+        var patternClause = (PropertyPatternClauseSyntax)context.Node;
 
-        SeparatedSyntaxList<SubpatternSyntax> subpatterns = objectCreation.Subpatterns;
+        SeparatedSyntaxList<SubpatternSyntax> subpatterns = patternClause.Subpatterns;
 
         if (!subpatterns.Any())
             return;
 
         int count = subpatterns.Count;
         int separatorCount = subpatterns.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(patternClause.OpenBraceToken.SpanStart, patternClause.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -241,7 +245,7 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte
                 ReportRemove(context, subpatterns.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && subpatterns.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(patternClause.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, subpatterns.GetSeparator(count - 1));
             }
@@ -253,7 +257,7 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte
                 ReportAdd(context, subpatterns.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !subpatterns.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(patternClause.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, subpatterns.Last());
             }
@@ -268,15 +272,16 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex
         if (style == TrailingCommaStyle.None)
             return;
 
-        var objectCreation = (CollectionExpressionSyntax)context.Node;
+        var collectionExpression = (CollectionExpressionSyntax)context.Node;
 
-        SeparatedSyntaxList<CollectionElementSyntax> elements = objectCreation.Elements;
+        SeparatedSyntaxList<CollectionElementSyntax> elements = collectionExpression.Elements;
 
         if (!elements.Any())
             return;
 
         int count = elements.Count;
         int separatorCount = elements.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(collectionExpression.OpenBracketToken.SpanStart, collectionExpression.CloseBracketToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -285,7 +290,7 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex
                 ReportRemove(context, elements.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && elements.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(collectionExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, elements.GetSeparator(count - 1));
             }
@@ -297,7 +302,7 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex
                 ReportAdd(context, elements.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !elements.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(collectionExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, elements.Last());
             }
diff --git a/src/Tests/Analyzers.Tests/RCS1260AddOrRemoveTrailingCommaTests.cs b/src/Tests/Analyzers.Tests/RCS1260AddOrRemoveTrailingCommaTests.cs
index 3c23e93902..065137a18c 100644
--- a/src/Tests/Analyzers.Tests/RCS1260AddOrRemoveTrailingCommaTests.cs
+++ b/src/Tests/Analyzers.Tests/RCS1260AddOrRemoveTrailingCommaTests.cs
@@ -108,6 +108,56 @@ void M()
 """, options: Options.AddConfigOption(ConfigOptionKeys.TrailingCommaStyle, ConfigOptionValues.TrailingCommaStyle_Include));
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.AddOrRemoveTrailingComma)]
+    public async Task Test_ArrayInitializer_OmitWhenSingleLine()
+    {
+        await VerifyDiagnosticAndFixAsync("""
+class C
+{
+    void M()
+    {
+        var arr = new[]
+        {
+            ""[||]
+        };
+    }
+}
+""", """
+class C
+{
+    void M()
+    {
+        var arr = new[]
+        {
+            "",
+        };
+    }
+}
+""", options: Options.AddConfigOption(ConfigOptionKeys.TrailingCommaStyle, ConfigOptionValues.TrailingCommaStyle_OmitWhenSingleLine));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.AddOrRemoveTrailingComma)]
+    public async Task Test_ArrayInitializer_OmitWhenSingleLine2()
+    {
+        await VerifyDiagnosticAndFixAsync("""
+class C
+{
+    void M()
+    {
+        var arr = new[] { ""[|,|] };
+    }
+}
+""", """
+class C
+{
+    void M()
+    {
+        var arr = new[] { "" };
+    }
+}
+""", options: Options.AddConfigOption(ConfigOptionKeys.TrailingCommaStyle, ConfigOptionValues.TrailingCommaStyle_OmitWhenSingleLine));
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.AddOrRemoveTrailingComma)]
     public async Task Test_ArrayInitializer_Omit()
     {