< Summary

Information
Class: System.Text.Json.Nodes.JsonArray
Assembly: System.Text.Json
File(s): File 1: C:\h\w\B31A098C\w\BB5A0A33\e\runtime-utils\Runner\runtime\src\libraries\System.Text.Json\src\System\Text\Json\Nodes\JsonArray.cs
File 2: C:\h\w\B31A098C\w\BB5A0A33\e\runtime-utils\Runner\runtime\src\libraries\System.Text.Json\src\System\Text\Json\Nodes\JsonArray.IList.cs
Line coverage
1%
Covered lines: 5
Uncovered lines: 246
Coverable lines: 251
Total lines: 641
Line coverage: 1.9%
Branch coverage
0%
Covered branches: 0
Total branches: 84
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
File 1: .ctor(...)100%110%
File 1: .ctor(...)100%110%
File 1: .ctor(...)100%110%
File 1: .ctor(...)100%110%
File 1: .ctor(...)100%110%
File 1: GetValueKindCore()100%110%
File 1: DeepCloneCore()0%880%
File 1: DeepEqualsCore(...)0%12120%
File 1: GetElementIndex(...)100%110%
File 1: GetValues()0%440%
File 1: InitializeFromArray(...)0%440%
File 1: InitializeFromSpan(...)0%440%
File 1: Create(...)0%440%
File 1: .ctor(...)100%11100%
File 1: Add(...)100%110%
File 1: GetItem(...)100%110%
File 1: SetItem(...)0%220%
File 1: GetPath(...)0%440%
File 1: WriteTo(...)0%880%
File 1: InitializeList()0%880%
File 1: GetUnderlyingRepresentation(...)100%110%
File 2: Add(...)0%220%
File 2: Clear()0%440%
File 2: Contains(...)100%110%
File 2: IndexOf(...)100%110%
File 2: Insert(...)0%220%
File 2: Remove(...)0%220%
File 2: RemoveAt(...)100%110%
File 2: RemoveAll(...)0%220%
File 2: RemoveRange(...)0%10100%
File 2: System.Collections.Generic.ICollection<System.Text.Json.Nodes.JsonNode>.CopyTo(...)100%110%
File 2: GetEnumerator()100%110%
File 2: System.Collections.IEnumerable.GetEnumerator()100%110%
File 2: DetachParent(...)0%220%

File(s)

C:\h\w\B31A098C\w\BB5A0A33\e\runtime-utils\Runner\runtime\src\libraries\System.Text.Json\src\System\Text\Json\Nodes\JsonArray.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Collections.Generic;
 5using System.Diagnostics;
 6using System.Diagnostics.CodeAnalysis;
 7using System.Text.Json.Serialization.Converters;
 8using System.Threading;
 9
 10namespace System.Text.Json.Nodes
 11{
 12    /// <summary>
 13    ///   Represents a mutable JSON array.
 14    /// </summary>
 15    /// <remarks>
 16    /// It is safe to perform multiple concurrent read operations on a <see cref="JsonArray"/>,
 17    /// but issues can occur if the collection is modified while it's being read.
 18    /// </remarks>
 19    [DebuggerDisplay("JsonArray[{List.Count}]")]
 20    [DebuggerTypeProxy(typeof(DebugView))]
 21    public sealed partial class JsonArray : JsonNode
 22    {
 23        private JsonElement? _jsonElement;
 24        private List<JsonNode?>? _list;
 25
 026        internal override JsonElement? UnderlyingElement => _jsonElement;
 27
 28        /// <summary>
 29        ///   Initializes a new instance of the <see cref="JsonArray"/> class that is empty.
 30        /// </summary>
 31        /// <param name="options">Options to control the behavior.</param>
 032        public JsonArray(JsonNodeOptions? options = null) : base(options) { }
 33
 34        /// <summary>
 35        ///   Initializes a new instance of the <see cref="JsonArray"/> class that contains items from the specified par
 36        /// </summary>
 37        /// <param name="options">Options to control the behavior.</param>
 38        /// <param name="items">The items to add to the new <see cref="JsonArray"/>.</param>
 039        public JsonArray(JsonNodeOptions options, params JsonNode?[] items) : base(options)
 040        {
 041            InitializeFromArray(items);
 042        }
 43
 44        /// <summary>
 45        ///   Initializes a new instance of the <see cref="JsonArray"/> class that contains items from the specified par
 46        /// </summary>
 47        /// <param name="options">Options to control the behavior.</param>
 48        /// <param name="items">The items to add to the new <see cref="JsonArray"/>.</param>
 049        public JsonArray(JsonNodeOptions options, params ReadOnlySpan<JsonNode?> items) : base(options)
 050        {
 051            InitializeFromSpan(items);
 052        }
 53
 54        /// <summary>
 55        ///   Initializes a new instance of the <see cref="JsonArray"/> class that contains items from the specified arr
 56        /// </summary>
 57        /// <param name="items">The items to add to the new <see cref="JsonArray"/>.</param>
 058        public JsonArray(params JsonNode?[] items) : base()
 059        {
 060            InitializeFromArray(items);
 061        }
 62
 63        /// <summary>
 64        ///   Initializes a new instance of the <see cref="JsonArray"/> class that contains items from the specified spa
 65        /// </summary>
 66        /// <param name="items">The items to add to the new <see cref="JsonArray"/>.</param>
 067        public JsonArray(params ReadOnlySpan<JsonNode?> items) : base()
 068        {
 069            InitializeFromSpan(items);
 070        }
 71
 072        private protected override JsonValueKind GetValueKindCore() => JsonValueKind.Array;
 73
 74        internal override JsonNode DeepCloneCore()
 075        {
 076            GetUnderlyingRepresentation(out List<JsonNode?>? list, out JsonElement? jsonElement);
 77
 078            if (list is null)
 079            {
 080                return jsonElement.HasValue
 081                    ? new JsonArray(jsonElement.Value.Clone(), Options)
 082                    : new JsonArray(Options);
 83            }
 84
 085            var jsonArray = new JsonArray(Options)
 086            {
 087                _list = new List<JsonNode?>(list.Count)
 088            };
 89
 090            for (int i = 0; i < list.Count; i++)
 091            {
 092                jsonArray.Add(list[i]?.DeepCloneCore());
 093            }
 94
 095            return jsonArray;
 096        }
 97
 98        internal override bool DeepEqualsCore(JsonNode node)
 099        {
 0100            switch (node)
 101            {
 102                case JsonObject:
 0103                    return false;
 104                case JsonValue value:
 105                    // JsonValue instances have special comparison semantics, dispatch to their implementation.
 0106                    return value.DeepEqualsCore(this);
 107                case JsonArray array:
 0108                    List<JsonNode?> currentList = List;
 0109                    List<JsonNode?> otherList = array.List;
 110
 0111                    if (currentList.Count != otherList.Count)
 0112                    {
 0113                        return false;
 114                    }
 115
 0116                    for (int i = 0; i < currentList.Count; i++)
 0117                    {
 0118                        if (!DeepEquals(currentList[i], otherList[i]))
 0119                        {
 0120                            return false;
 121                        }
 0122                    }
 123
 0124                    return true;
 125                default:
 0126                    Debug.Fail("Impossible case");
 127                    return false;
 128            }
 0129        }
 130
 131        internal int GetElementIndex(JsonNode? node)
 0132        {
 0133            return List.IndexOf(node);
 0134        }
 135
 136        /// <summary>
 137        /// Returns an enumerable that wraps calls to <see cref="JsonNode.GetValue{T}"/>.
 138        /// </summary>
 139        /// <typeparam name="T">The type of the value to obtain from the <see cref="JsonValue"/>.</typeparam>
 140        /// <returns>An enumerable iterating over values of the array.</returns>
 141        public IEnumerable<T> GetValues<T>()
 0142        {
 0143            foreach (JsonNode? item in List)
 0144            {
 0145                yield return item is null ? (T)(object?)null! : item.GetValue<T>();
 0146            }
 0147        }
 148
 149        private void InitializeFromArray(JsonNode?[] items)
 0150        {
 0151            var list = new List<JsonNode?>(items);
 152
 0153            for (int i = 0; i < list.Count; i++)
 0154            {
 0155                list[i]?.AssignParent(this);
 0156            }
 157
 0158            _list = list;
 0159        }
 160
 161        private void InitializeFromSpan(ReadOnlySpan<JsonNode?> items)
 0162        {
 0163            List<JsonNode?> list = new(items.Length);
 164
 165#if NET
 0166            list.AddRange(items);
 167#else
 168            foreach (JsonNode? item in items)
 169            {
 170                list.Add(item);
 171            }
 172#endif
 173
 0174            for (int i = 0; i < list.Count; i++)
 0175            {
 0176                list[i]?.AssignParent(this);
 0177            }
 178
 0179            _list = list;
 0180        }
 181
 182        /// <summary>
 183        ///   Initializes a new instance of the <see cref="JsonArray"/> class that contains items from the specified <se
 184        /// </summary>
 185        /// <returns>
 186        ///   The new instance of the <see cref="JsonArray"/> class that contains items from the specified <see cref="Js
 187        /// </returns>
 188        /// <param name="element">The <see cref="JsonElement"/>.</param>
 189        /// <param name="options">Options to control the behavior.</param>
 190        /// <exception cref="InvalidOperationException">
 191        ///   The <paramref name="element"/> is not a <see cref="JsonValueKind.Array"/>.
 192        /// </exception>
 193        public static JsonArray? Create(JsonElement element, JsonNodeOptions? options = null)
 0194        {
 0195            return element.ValueKind switch
 0196            {
 0197                JsonValueKind.Null => null,
 0198                JsonValueKind.Array => new JsonArray(element, options),
 0199                _ => throw new InvalidOperationException(SR.Format(SR.NodeElementWrongType, nameof(JsonValueKind.Array))
 0200            };
 0201        }
 202
 44203        internal JsonArray(JsonElement element, JsonNodeOptions? options = null) : base(options)
 44204        {
 44205            Debug.Assert(element.ValueKind == JsonValueKind.Array);
 44206            _jsonElement = element;
 44207        }
 208
 209        /// <summary>
 210        ///   Adds an object to the end of the <see cref="JsonArray"/>.
 211        /// </summary>
 212        /// <typeparam name="T">The type of object to be added.</typeparam>
 213        /// <param name="value">
 214        ///   The object to be added to the end of the <see cref="JsonArray"/>.
 215        /// </param>
 216        [RequiresUnreferencedCode(JsonValue.CreateUnreferencedCodeMessage)]
 217        [RequiresDynamicCode(JsonValue.CreateDynamicCodeMessage)]
 218        public void Add<T>(T? value)
 0219        {
 0220            JsonNode? nodeToAdd = ConvertFromValue(value, Options);
 0221            Add(nodeToAdd);
 0222        }
 223
 224        /// <summary>
 225        /// Gets or creates the underlying list containing the element nodes of the array.
 226        /// </summary>
 0227        private List<JsonNode?> List => _list ?? InitializeList();
 228
 229        private protected override JsonNode? GetItem(int index)
 0230        {
 0231            return List[index];
 0232        }
 233
 234        private protected override void SetItem(int index, JsonNode? value)
 0235        {
 0236            value?.AssignParent(this);
 0237            DetachParent(List[index]);
 0238            List[index] = value;
 0239        }
 240
 241        internal override void GetPath(ref ValueStringBuilder path, JsonNode? child)
 0242        {
 0243            Parent?.GetPath(ref path, this);
 244
 0245            if (child != null)
 0246            {
 0247                int index = List.IndexOf(child);
 0248                Debug.Assert(index >= 0);
 249
 0250                path.Append('[');
 251#if NET
 0252                Span<char> chars = stackalloc char[JsonConstants.MaximumFormatUInt32Length];
 0253                bool formatted = ((uint)index).TryFormat(chars, out int charsWritten);
 0254                Debug.Assert(formatted);
 0255                path.Append(chars.Slice(0, charsWritten));
 256#else
 257                path.Append(index.ToString());
 258#endif
 0259                path.Append(']');
 0260            }
 0261        }
 262
 263        /// <inheritdoc/>
 264        public override void WriteTo(Utf8JsonWriter writer, JsonSerializerOptions? options = null)
 0265        {
 0266            ArgumentNullException.ThrowIfNull(writer);
 267
 0268            GetUnderlyingRepresentation(out List<JsonNode?>? list, out JsonElement? jsonElement);
 269
 0270            if (list is null && jsonElement.HasValue)
 0271            {
 0272                jsonElement.Value.WriteTo(writer);
 0273            }
 274            else
 0275            {
 0276                writer.WriteStartArray();
 277
 0278                foreach (JsonNode? element in List)
 0279                {
 0280                    if (element is null)
 0281                    {
 0282                        writer.WriteNullValue();
 0283                    }
 284                    else
 0285                    {
 0286                        element.WriteTo(writer, options);
 0287                    }
 0288                }
 289
 0290                writer.WriteEndArray();
 0291            }
 0292        }
 293
 294        private List<JsonNode?> InitializeList()
 0295        {
 0296            GetUnderlyingRepresentation(out List<JsonNode?>? list, out JsonElement? jsonElement);
 297
 0298            if (list is null)
 0299            {
 0300                if (jsonElement.HasValue)
 0301                {
 0302                    JsonElement jElement = jsonElement.Value;
 0303                    Debug.Assert(jElement.ValueKind == JsonValueKind.Array);
 304
 0305                    list = new List<JsonNode?>(jElement.GetArrayLength());
 306
 0307                    foreach (JsonElement element in jElement.EnumerateArray())
 0308                    {
 0309                        JsonNode? node = JsonNodeConverter.Create(element, Options);
 0310                        node?.AssignParent(this);
 0311                        list.Add(node);
 0312                    }
 0313                }
 314                else
 0315                {
 0316                    list = new();
 0317                }
 318
 319                // Ensure _jsonElement is written to after _list
 0320                _list = list;
 0321                Interlocked.MemoryBarrier();
 0322                _jsonElement = null;
 0323            }
 324
 0325            return list;
 0326        }
 327
 328        /// <summary>
 329        /// Provides a coherent view of the underlying representation of the current node.
 330        /// The jsonElement value should be consumed if and only if the list value is null.
 331        /// </summary>
 332        private void GetUnderlyingRepresentation(out List<JsonNode?>? list, out JsonElement? jsonElement)
 0333        {
 334            // Because JsonElement cannot be read atomically there might be torn reads,
 335            // however the order of read/write operations guarantees that that's only
 336            // possible if the value of _list is non-null.
 0337            jsonElement = _jsonElement;
 0338            Interlocked.MemoryBarrier();
 0339            list = _list;
 0340        }
 341
 342        [ExcludeFromCodeCoverage] // Justification = "Design-time"
 343        private sealed class DebugView
 344        {
 345            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
 346            private readonly JsonArray _node;
 347
 348            public DebugView(JsonArray node)
 349            {
 350                _node = node;
 351            }
 352
 353            public string Json => _node.ToJsonString();
 354            public string Path => _node.GetPath();
 355
 356            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
 357            private DebugViewItem[] Items
 358            {
 359                get
 360                {
 361                    DebugViewItem[] properties = new DebugViewItem[_node.List.Count];
 362
 363                    for (int i = 0; i < _node.List.Count; i++)
 364                    {
 365                        properties[i].Value = _node.List[i];
 366                    }
 367
 368                    return properties;
 369                }
 370            }
 371
 372            [DebuggerDisplay("{Display,nq}")]
 373            private struct DebugViewItem
 374            {
 375                [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
 376                public JsonNode? Value;
 377
 378                [DebuggerBrowsable(DebuggerBrowsableState.Never)]
 379                public string Display
 380                {
 381                    get
 382                    {
 383                        if (Value == null)
 384                        {
 385                            return $"null";
 386                        }
 387
 388                        if (Value is JsonValue)
 389                        {
 390                            return Value.ToJsonString();
 391                        }
 392
 393                        if (Value is JsonObject jsonObject)
 394                        {
 395                            return $"JsonObject[{jsonObject.Count}]";
 396                        }
 397
 398                        JsonArray jsonArray = (JsonArray)Value;
 399                        return $"JsonArray[{jsonArray.List.Count}]";
 400                    }
 401                }
 402            }
 403        }
 404    }
 405}

C:\h\w\B31A098C\w\BB5A0A33\e\runtime-utils\Runner\runtime\src\libraries\System.Text.Json\src\System\Text\Json\Nodes\JsonArray.IList.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Collections;
 5using System.Collections.Generic;
 6
 7namespace System.Text.Json.Nodes
 8{
 9    public sealed partial class JsonArray : JsonNode, IList<JsonNode?>
 10    {
 11        /// <summary>
 12        ///   Gets the number of elements contained in the <see cref="JsonArray"/>.
 13        /// </summary>
 014        public int Count => List.Count;
 15
 16        /// <summary>
 17        ///   Adds a <see cref="JsonNode"/> to the end of the <see cref="JsonArray"/>.
 18        /// </summary>
 19        /// <param name="item">
 20        ///   The <see cref="JsonNode"/> to be added to the end of the <see cref="JsonArray"/>.
 21        /// </param>
 22        public void Add(JsonNode? item)
 023        {
 024            item?.AssignParent(this);
 25
 026            List.Add(item);
 027        }
 28
 29        /// <summary>
 30        ///   Removes all elements from the <see cref="JsonArray"/>.
 31        /// </summary>
 32        public void Clear()
 033        {
 034            List<JsonNode?>? list = _list;
 35
 036            if (list is null)
 037            {
 038                _jsonElement = null;
 039            }
 40            else
 041            {
 042                for (int i = 0; i < list.Count; i++)
 043                {
 044                    DetachParent(list[i]);
 045                }
 46
 047                list.Clear();
 048            }
 049        }
 50
 51        /// <summary>
 52        ///   Determines whether an element is in the <see cref="JsonArray"/>.
 53        /// </summary>
 54        /// <param name="item">The object to locate in the <see cref="JsonArray"/>.</param>
 55        /// <returns>
 56        ///   <see langword="true"/> if <paramref name="item"/> is found in the <see cref="JsonArray"/>; otherwise, <see
 57        /// </returns>
 058        public bool Contains(JsonNode? item) => List.Contains(item);
 59
 60        /// <summary>
 61        ///   The object to locate in the <see cref="JsonArray"/>.
 62        /// </summary>
 63        /// <param name="item">The <see cref="JsonNode"/> to locate in the <see cref="JsonArray"/>.</param>
 64        /// <returns>
 65        ///  The index of item if found in the list; otherwise, -1.
 66        /// </returns>
 067        public int IndexOf(JsonNode? item) => List.IndexOf(item);
 68
 69        /// <summary>
 70        ///   Inserts an element into the <see cref="JsonArray"/> at the specified index.
 71        /// </summary>
 72        /// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
 73        /// <param name="item">The <see cref="JsonNode"/> to insert.</param>
 74        /// <exception cref="ArgumentOutOfRangeException">
 75        ///   <paramref name="index"/> is less than 0 or <paramref name="index"/> is greater than <see cref="Count"/>.
 76        /// </exception>
 77        public void Insert(int index, JsonNode? item)
 078        {
 079            item?.AssignParent(this);
 080            List.Insert(index, item);
 081        }
 82
 83        /// <summary>
 84        ///   Removes the first occurrence of a specific <see cref="JsonNode"/> from the <see cref="JsonArray"/>.
 85        /// </summary>
 86        /// <param name="item">
 87        ///   The <see cref="JsonNode"/> to remove from the <see cref="JsonArray"/>.
 88        /// </param>
 89        /// <returns>
 90        ///   <see langword="true"/> if <paramref name="item"/> is successfully removed; otherwise, <see langword="false
 91        /// </returns>
 92        public bool Remove(JsonNode? item)
 093        {
 094            if (List.Remove(item))
 095            {
 096                DetachParent(item);
 097                return true;
 98            }
 99
 0100            return false;
 0101        }
 102
 103        /// <summary>
 104        ///   Removes the element at the specified index of the <see cref="JsonArray"/>.
 105        /// </summary>
 106        /// <param name="index">The zero-based index of the element to remove.</param>
 107        /// <exception cref="ArgumentOutOfRangeException">
 108        ///   <paramref name="index"/> is less than 0 or <paramref name="index"/> is greater than <see cref="Count"/>.
 109        /// </exception>
 110        public void RemoveAt(int index)
 0111        {
 0112            JsonNode? item = List[index];
 0113            List.RemoveAt(index);
 0114            DetachParent(item);
 0115        }
 116
 117        /// <summary>
 118        ///   Removes all the elements that match the conditions defined by the specified predicate.
 119        /// </summary>
 120        /// <param name="match">The predicate that defines the conditions of the elements to remove.</param>
 121        /// <returns>The number of elements removed from the <see cref="JsonArray"/>.</returns>
 122        /// <exception cref="ArgumentNullException">
 123        ///   <paramref name="match"/> is <see langword="null"/>.
 124        /// </exception>
 125        public int RemoveAll(Func<JsonNode?, bool> match)
 0126        {
 0127            ArgumentNullException.ThrowIfNull(match);
 128
 0129            return List.RemoveAll(node =>
 0130            {
 0131                if (match(node))
 0132                {
 0133                    DetachParent(node);
 0134                    return true;
 0135                }
 0136                else
 0137                {
 0138                    return false;
 0139                }
 0140            });
 0141        }
 142
 143        /// <summary>
 144        ///   Removes a range of elements from the <see cref="JsonArray"/>.
 145        /// </summary>
 146        /// <param name="index">The zero-based starting index of the range of elements to remove.</param>
 147        /// <param name="count">The number of elements to remove.</param>
 148        /// <exception cref="ArgumentOutOfRangeException">
 149        ///   <paramref name="index"/> or <paramref name="count"/> is less than 0.
 150        /// </exception>
 151        /// <exception cref="ArgumentException">
 152        ///   <paramref name="index"/> and <paramref name="count"/> do not denote a valid range of elements in the <see 
 153        /// </exception>
 154        public void RemoveRange(int index, int count)
 0155        {
 0156            if (index < 0)
 0157            {
 0158                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(index));
 159            }
 160
 0161            if (count < 0)
 0162            {
 0163                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(count));
 164            }
 165
 0166            List<JsonNode?> list = List;
 167
 0168            if (list.Count - index < count)
 0169            {
 0170                ThrowHelper.ThrowArgumentException_InvalidOffLen();
 171            }
 172
 0173            if (count > 0)
 0174            {
 0175                for (int i = 0; i < count; i++)
 0176                {
 0177                    DetachParent(list[index + i]);
 178                    // There's no need to assign nulls because List<>.RemoveRange calls
 179                    // Array.Clear on the removed partition.
 0180                }
 181
 0182                list.RemoveRange(index, count);
 0183            }
 0184        }
 185
 186        #region Explicit interface implementation
 187
 188        /// <summary>
 189        ///   Copies the entire <see cref="Array"/> to a compatible one-dimensional array,
 190        ///   starting at the specified index of the target array.
 191        /// </summary>
 192        /// <param name="array">
 193        ///   The one-dimensional <see cref="Array"/> that is the destination of the elements copied
 194        ///   from <see cref="JsonArray"/>. The Array must have zero-based indexing.</param>
 195        /// <param name="index">
 196        ///   The zero-based index in <paramref name="array"/> at which copying begins.
 197        /// </param>
 198        /// <exception cref="ArgumentNullException">
 199        ///   <paramref name="array"/> is <see langword="null"/>.
 200        /// </exception>
 201        /// <exception cref="ArgumentOutOfRangeException">
 202        ///   <paramref name="index"/> is less than 0.
 203        /// </exception>
 204        /// <exception cref="ArgumentException">
 205        ///   The number of elements in the source ICollection is greater than the available space from <paramref name="
 206        ///   to the end of the destination <paramref name="array"/>.
 207        /// </exception>
 0208        void ICollection<JsonNode?>.CopyTo(JsonNode?[] array, int index) => List.CopyTo(array, index);
 209
 210        /// <summary>
 211        ///   Returns an enumerator that iterates through the <see cref="JsonArray"/>.
 212        /// </summary>
 213        /// <returns>A <see cref="IEnumerator{JsonNode}"/> for the <see cref="JsonNode"/>.</returns>
 0214        public IEnumerator<JsonNode?> GetEnumerator() => List.GetEnumerator();
 215
 216        /// <summary>
 217        ///   Returns an enumerator that iterates through the <see cref="JsonArray"/>.
 218        /// </summary>
 219        /// <returns>
 220        ///   A <see cref="IEnumerator"/> for the <see cref="JsonArray"/>.
 221        /// </returns>
 0222        IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)List).GetEnumerator();
 223
 224        /// <summary>
 225        ///   Returns <see langword="false"/>.
 226        /// </summary>
 0227        bool ICollection<JsonNode?>.IsReadOnly => false;
 228
 229        #endregion
 230
 231        private static void DetachParent(JsonNode? item)
 0232        {
 0233            item?.Parent = null;
 0234        }
 235    }
 236}
Generated by: ReportGenerator 5.5.1.0
2/25/2026 - 11:57:03 AM
GitHub | reportgenerator.io

Methods/Properties

UnderlyingElement()
.ctor(System.Nullable`1<System.Text.Json.Nodes.JsonNodeOptions>)
.ctor(System.Text.Json.Nodes.JsonNodeOptions,System.Text.Json.Nodes.JsonNode[])
.ctor(System.Text.Json.Nodes.JsonNodeOptions,System.ReadOnlySpan`1<System.Text.Json.Nodes.JsonNode>)
.ctor(System.Text.Json.Nodes.JsonNode[])
.ctor(System.ReadOnlySpan`1<System.Text.Json.Nodes.JsonNode>)
GetValueKindCore()
DeepCloneCore()
DeepEqualsCore(System.Text.Json.Nodes.JsonNode)
GetElementIndex(System.Text.Json.Nodes.JsonNode)
GetValues()
InitializeFromArray(System.Text.Json.Nodes.JsonNode[])
InitializeFromSpan(System.ReadOnlySpan`1<System.Text.Json.Nodes.JsonNode>)
Create(System.Text.Json.JsonElement,System.Nullable`1<System.Text.Json.Nodes.JsonNodeOptions>)
.ctor(System.Text.Json.JsonElement,System.Nullable`1<System.Text.Json.Nodes.JsonNodeOptions>)
Add(T)
List()
GetItem(System.Int32)
SetItem(System.Int32,System.Text.Json.Nodes.JsonNode)
GetPath(System.Text.ValueStringBuilder&,System.Text.Json.Nodes.JsonNode)
WriteTo(System.Text.Json.Utf8JsonWriter,System.Text.Json.JsonSerializerOptions)
InitializeList()
GetUnderlyingRepresentation(System.Collections.Generic.List`1<System.Text.Json.Nodes.JsonNode>&,System.Nullable`1<System.Text.Json.JsonElement>&)
Count()
Add(System.Text.Json.Nodes.JsonNode)
Clear()
Contains(System.Text.Json.Nodes.JsonNode)
IndexOf(System.Text.Json.Nodes.JsonNode)
Insert(System.Int32,System.Text.Json.Nodes.JsonNode)
Remove(System.Text.Json.Nodes.JsonNode)
RemoveAt(System.Int32)
RemoveAll(System.Func`2<System.Text.Json.Nodes.JsonNode,System.Boolean>)
RemoveRange(System.Int32,System.Int32)
System.Collections.Generic.ICollection<System.Text.Json.Nodes.JsonNode>.CopyTo(System.Text.Json.Nodes.JsonNode[],System.Int32)
GetEnumerator()
System.Collections.IEnumerable.GetEnumerator()
em.Collections.Generic.ICollection<System.Text.Json.Nodes.JsonNode>.get_IsReadOnly()
DetachParent(System.Text.Json.Nodes.JsonNode)