From 9b00b725d15e66b6f6ffd9f5b21569b2275909ee Mon Sep 17 00:00:00 2001 From: Witold Ksiazek Date: Tue, 21 Jan 2020 18:56:44 +0100 Subject: [PATCH] Initial Commit --- .DS_Store | Bin 0 -> 8196 bytes FodyWeavers.xml | 3 + FodyWeavers.xsd | 54 + Images/.DS_Store | Bin 0 -> 6148 bytes Images/Characters/characters_atlas.png | Bin 0 -> 1477 bytes Images/Characters/characters_atlas.png.import | 34 + Images/Characters/knecht.tres | 8 + Images/Grounds/ground_tile_set.tres | 21 + Images/Grounds/ground_tiles.png | Bin 0 -> 2883 bytes Images/Grounds/ground_tiles.png.import | 34 + Images/icon.png | Bin 0 -> 3433 bytes Images/icon.png.import | 34 + Model/Board.cs | 17 + Model/Commands/Command.cs | 29 + Model/Commands/CommandType.cs | 6 + Model/Field.cs | 14 + Model/Grounds/Ground.cs | 11 + Model/Grounds/GroundType.cs | 12 + Model/Grounds/GroundTypeConfig.cs | 5 + Model/Grounds/GroundTypesFactory.cs | 35 + Model/IBoard.cs | 8 + Model/IGame.cs | 6 + Model/Math/IntVector2.cs | 50 + Model/Units/Hero.cs | 7 + Model/Units/HeroesManager.cs | 11 + Model/Units/IHero.cs | 7 + Model/Units/IHeroesManager.cs | 7 + PlayerSupport/ActionPlan.cs | 25 + PlayerSupport/ActionPlanner.cs | 28 + PlayerSupport/Ai/PathFinding/Node.cs | 22 + PlayerSupport/Ai/PathFinding/PathFinder.cs | 59 + .../PriorityQueues/PriorityQueue.cs | 75 + .../PriorityQueues/WeightedNode.cs | 17 + .../Ai/PathFinding/WeightsFactory.cs | 36 + Properties/Annotations.cs | 1239 ++++ Properties/AssemblyInfo.cs | 25 + Shaders/Highlight.shader | 39 + Shaders/HighlightMaterial.tres | 10 + Shaders/SelectionMaterial.tres | 10 + Stage.tscn | 70 + TradingCompany.csproj | 97 + TradingCompany.sln | 19 + TradingCompany.sln.DotSettings | 2 + View/.DS_Store | Bin 0 -> 6148 bytes View/Board/BoardInitializer.cs | 24 + View/Board/BoardStore.cs | 16 + View/EventDispatcher.cs | 52 + View/EventType.cs | 8 + View/GameInitializer.cs | 14 + View/Highlighting/HighlightingController.cs | 18 + View/Highlighting/TilesHighlightingLayer.cs | 43 + View/Highlighting/TilesHighlightingStore.cs | 33 + View/Input/MouseController.cs | 20 + View/Input/MouseStore.cs | 15 + View/Selection/TilesSelectionLayer.cs | 56 + View/Stores.cs | 17 + default_env.tres | 7 + packages.config | 4 + .../.signature.p7s | Bin 0 -> 18704 bytes .../LICENSE.TXT | 23 + ...ns.Immutable.1.7.0-preview1.19504.10.nupkg | Bin 0 -> 481097 bytes .../THIRD-PARTY-NOTICES.TXT | 375 ++ .../System.Collections.Immutable.dll | Bin 0 -> 180088 bytes .../System.Collections.Immutable.xml | 5141 +++++++++++++++++ .../System.Collections.Immutable.dll | Bin 0 -> 181624 bytes .../System.Collections.Immutable.xml | 5141 +++++++++++++++++ .../System.Collections.Immutable.dll | Bin 0 -> 180096 bytes .../System.Collections.Immutable.xml | 5141 +++++++++++++++++ .../System.Collections.Immutable.dll | Bin 0 -> 180088 bytes .../System.Collections.Immutable.xml | 5141 +++++++++++++++++ .../useSharedDesignerContext.txt | 0 .../version.txt | 1 + project.godot | 24 + 73 files changed, 23500 insertions(+) create mode 100644 .DS_Store create mode 100644 FodyWeavers.xml create mode 100644 FodyWeavers.xsd create mode 100644 Images/.DS_Store create mode 100644 Images/Characters/characters_atlas.png create mode 100644 Images/Characters/characters_atlas.png.import create mode 100644 Images/Characters/knecht.tres create mode 100644 Images/Grounds/ground_tile_set.tres create mode 100644 Images/Grounds/ground_tiles.png create mode 100644 Images/Grounds/ground_tiles.png.import create mode 100644 Images/icon.png create mode 100644 Images/icon.png.import create mode 100644 Model/Board.cs create mode 100644 Model/Commands/Command.cs create mode 100644 Model/Commands/CommandType.cs create mode 100644 Model/Field.cs create mode 100644 Model/Grounds/Ground.cs create mode 100644 Model/Grounds/GroundType.cs create mode 100644 Model/Grounds/GroundTypeConfig.cs create mode 100644 Model/Grounds/GroundTypesFactory.cs create mode 100644 Model/IBoard.cs create mode 100644 Model/IGame.cs create mode 100644 Model/Math/IntVector2.cs create mode 100644 Model/Units/Hero.cs create mode 100644 Model/Units/HeroesManager.cs create mode 100644 Model/Units/IHero.cs create mode 100644 Model/Units/IHeroesManager.cs create mode 100644 PlayerSupport/ActionPlan.cs create mode 100644 PlayerSupport/ActionPlanner.cs create mode 100644 PlayerSupport/Ai/PathFinding/Node.cs create mode 100644 PlayerSupport/Ai/PathFinding/PathFinder.cs create mode 100644 PlayerSupport/Ai/PathFinding/PriorityQueues/PriorityQueue.cs create mode 100644 PlayerSupport/Ai/PathFinding/PriorityQueues/WeightedNode.cs create mode 100644 PlayerSupport/Ai/PathFinding/WeightsFactory.cs create mode 100644 Properties/Annotations.cs create mode 100644 Properties/AssemblyInfo.cs create mode 100644 Shaders/Highlight.shader create mode 100644 Shaders/HighlightMaterial.tres create mode 100644 Shaders/SelectionMaterial.tres create mode 100644 Stage.tscn create mode 100644 TradingCompany.csproj create mode 100644 TradingCompany.sln create mode 100644 TradingCompany.sln.DotSettings create mode 100644 View/.DS_Store create mode 100644 View/Board/BoardInitializer.cs create mode 100644 View/Board/BoardStore.cs create mode 100644 View/EventDispatcher.cs create mode 100644 View/EventType.cs create mode 100644 View/GameInitializer.cs create mode 100644 View/Highlighting/HighlightingController.cs create mode 100644 View/Highlighting/TilesHighlightingLayer.cs create mode 100644 View/Highlighting/TilesHighlightingStore.cs create mode 100644 View/Input/MouseController.cs create mode 100644 View/Input/MouseStore.cs create mode 100644 View/Selection/TilesSelectionLayer.cs create mode 100644 View/Stores.cs create mode 100644 default_env.tres create mode 100644 packages.config create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/.signature.p7s create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/LICENSE.TXT create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/System.Collections.Immutable.1.7.0-preview1.19504.10.nupkg create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/THIRD-PARTY-NOTICES.TXT create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.0/System.Collections.Immutable.dll create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.0/System.Collections.Immutable.xml create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.3/System.Collections.Immutable.dll create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.3/System.Collections.Immutable.xml create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard2.0/System.Collections.Immutable.dll create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard2.0/System.Collections.Immutable.xml create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.dll create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.xml create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/useSharedDesignerContext.txt create mode 100755 packages/System.Collections.Immutable.1.7.0-preview1.19504.10/version.txt create mode 100644 project.godot diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..aa59042f365c5bafffef8614cb9ca137599a05e7 GIT binary patch literal 8196 zcmeHM(M}UV6ukolmKs81RCpr$V&VfKkb=Y*lUk|?4<;lf@PG!k-P%^SJDcv7g0-eE z{)74lCjNwvet{q1qaUE>&Q5A~3!+aNm}zG2?9M%R?mc(ta<@bziXC^2Xpx94be6em z7|v+C&V8&+=sUL{1@J^2@+hK1s*yjYZEhF_3GHFz`PxfM+&0>zwC)ylO_n zfMMWDGQi&tHag3KmV;QTuMP~V1c1!owrZH84p10d%Yv4JSSl!N#?^z+P@zi<5yP== zvpQr!%Rww-IEffeLhmeeg(B4Mz}ZTjL?M=DGz=I9#u?z+Jx4Ao_UGgz>i1(>K`r0L zO1SOGYQ>WkrAu@l^3D&{l)-s=OcFLuX&>4S9b;@$2>c1P$V;I={slTDH;EPtDfBdL zV-JVw<9>>_zti>VYvrnJ1uBAgNZ4x0Qc1^b)tB6ZZ=XItgj!0+y-+7;jO{Z;PZVFZ zG&kaV%43TH#8#!3XGf?q@h*{xlsg#rxxcd z=^Jw*tPxJK(2g{Je4;~m=%+AXB7wO{yRghVG{Ie+w%}n)<-!L$%xQ=#6>-uMGn24% z{Q^rN7*Bb_=Qd$u=}&CHs}l2#XlodmN%lO&4s)5XouNI&c{dq{V)0~z#i3rM8wUFC z;!7p)nqjoM`c+I!W~QcREGuhe=d#br4cRS6PSgpDPWynbcAThD(eqs?z2V%c>@{oM z!`zK6=|@h}ueBAp>DHj~bie7lvRjlL-wl>;9YfICN-2|L;Ka@%3>0fY~s><8s^gq+e&iP{T|N z1DB40$vC1#uKypM|Nj5d#ccvI3>XG}F(5Lfa;b>x^PYEHYuo5Y=-gOu5K9HYpvrMb jRgOare=x+{hALwUS`K1~J81vnMSyw!E9%W~g&Ft>h)HBW literal 0 HcmV?d00001 diff --git a/FodyWeavers.xml b/FodyWeavers.xml new file mode 100644 index 0000000..d5abfed --- /dev/null +++ b/FodyWeavers.xml @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/FodyWeavers.xsd b/FodyWeavers.xsd new file mode 100644 index 0000000..2f1b8aa --- /dev/null +++ b/FodyWeavers.xsd @@ -0,0 +1,54 @@ + + + + + + + + + + + Used to control if the On_PropertyName_Changed feature is enabled. + + + + + Used to change the name of the method that fires the notify event. This is a string that accepts multiple values in a comma separated form. + + + + + Used to control if equality checks should be inserted. If false, equality checking will be disabled for the project. + + + + + Used to control if equality checks should use the Equals method resolved from the base class. + + + + + Used to control if equality checks should use the static Equals method resolved from the base class. + + + + + + + + 'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed. + + + + + A comma-separated list of error codes that can be safely ignored in assembly verification. + + + + + 'false' to turn off automatic generation of the XML Schema file. + + + + + \ No newline at end of file diff --git a/Images/.DS_Store b/Images/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5738b83c0679f9e4d6bdd4cebd61b7e0e1d48324 GIT binary patch literal 6148 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 LNkvXXu0mjfd922> literal 0 HcmV?d00001 diff --git a/Images/icon.png.import b/Images/icon.png.import new file mode 100644 index 0000000..0d0b95b --- /dev/null +++ b/Images/icon.png.import @@ -0,0 +1,34 @@ +[remap] + +importer="texture" +type="StreamTexture" +path="res://.import/icon.png-5c54608cdf98940b04ad240121483c81.stex" +metadata={ +"vram_texture": false +} + +[deps] + +source_file="res://Images/icon.png" +dest_files=[ "res://.import/icon.png-5c54608cdf98940b04ad240121483c81.stex" ] + +[params] + +compress/mode=0 +compress/lossy_quality=0.7 +compress/hdr_mode=0 +compress/bptc_ldr=0 +compress/normal_map=0 +flags/repeat=0 +flags/filter=true +flags/mipmaps=false +flags/anisotropic=false +flags/srgb=2 +process/fix_alpha_border=true +process/premult_alpha=false +process/HDR_as_SRGB=false +process/invert_color=false +stream=false +size_limit=0 +detect_3d=true +svg/scale=1.0 diff --git a/Model/Board.cs b/Model/Board.cs new file mode 100644 index 0000000..ee813be --- /dev/null +++ b/Model/Board.cs @@ -0,0 +1,17 @@ +namespace TradingCompany.Model { + public class Board : IBoard { + public Board(Field[][] fields) { + Fields = fields; + + Rows = fields.Length; + Columns = fields[0].Length; + } + + public Field[][] Fields { get; } + + + public int Rows { get; } + + public int Columns { get; } + } +} \ No newline at end of file diff --git a/Model/Commands/Command.cs b/Model/Commands/Command.cs new file mode 100644 index 0000000..2b24505 --- /dev/null +++ b/Model/Commands/Command.cs @@ -0,0 +1,29 @@ +using System; +using TradingCompany.Model.Math; + +namespace TradingCompany.Model.Commands { + public struct Command : IEquatable { + public readonly IntVector2 TargetPosition; + public readonly CommandType Type; + + public Command(IntVector2 targetPosition, + CommandType type) { + TargetPosition = targetPosition; + Type = type; + } + + public bool Equals(Command other) { + return TargetPosition.Equals(other.TargetPosition) && Type == other.Type; + } + + public override bool Equals(object obj) { + return obj is Command other && Equals(other); + } + + public override int GetHashCode() { + unchecked { + return (TargetPosition.GetHashCode() * 397) ^ (int) Type; + } + } + } +} \ No newline at end of file diff --git a/Model/Commands/CommandType.cs b/Model/Commands/CommandType.cs new file mode 100644 index 0000000..5e18c6a --- /dev/null +++ b/Model/Commands/CommandType.cs @@ -0,0 +1,6 @@ +namespace TradingCompany.Model.Commands { + public enum CommandType { + Move, + Attack + } +} \ No newline at end of file diff --git a/Model/Field.cs b/Model/Field.cs new file mode 100644 index 0000000..97a683a --- /dev/null +++ b/Model/Field.cs @@ -0,0 +1,14 @@ +using TradingCompany.Model.Grounds; + +namespace TradingCompany.Model { + public struct Field { + public readonly int Row, Column; + public readonly Ground Ground; + + public Field(int row, int column, Ground ground) { + Row = row; + Column = column; + Ground = ground; + } + } +} \ No newline at end of file diff --git a/Model/Grounds/Ground.cs b/Model/Grounds/Ground.cs new file mode 100644 index 0000000..0de9d09 --- /dev/null +++ b/Model/Grounds/Ground.cs @@ -0,0 +1,11 @@ +namespace TradingCompany.Model.Grounds { + public struct Ground { + public GroundType GroundType; + public bool IsAccessible; + + public Ground(GroundType groundType, bool isAccessible) { + GroundType = groundType; + IsAccessible = isAccessible; + } + } +} \ No newline at end of file diff --git a/Model/Grounds/GroundType.cs b/Model/Grounds/GroundType.cs new file mode 100644 index 0000000..101ab8a --- /dev/null +++ b/Model/Grounds/GroundType.cs @@ -0,0 +1,12 @@ +namespace TradingCompany.Model.Grounds { + /// + /// View Contract: + /// The order in this enumerable needs to match the order of Tiles in the ground_tile_set.tres + /// + public enum GroundType { + Water, + Grass, + Forest, + Castle + } +} \ No newline at end of file diff --git a/Model/Grounds/GroundTypeConfig.cs b/Model/Grounds/GroundTypeConfig.cs new file mode 100644 index 0000000..706b615 --- /dev/null +++ b/Model/Grounds/GroundTypeConfig.cs @@ -0,0 +1,5 @@ +namespace TradingCompany.Model.Grounds { + public class GroundTypeConfig { + public bool IsAccessible; + } +} \ No newline at end of file diff --git a/Model/Grounds/GroundTypesFactory.cs b/Model/Grounds/GroundTypesFactory.cs new file mode 100644 index 0000000..7cdd381 --- /dev/null +++ b/Model/Grounds/GroundTypesFactory.cs @@ -0,0 +1,35 @@ +using System.Collections.Generic; + +namespace TradingCompany.Model.Grounds { + public static class GroundTypesFactory { + private static readonly Dictionary Configs = + new Dictionary { + { + GroundType.Water, + new GroundTypeConfig { + IsAccessible = false + } + }, { + GroundType.Grass, + new GroundTypeConfig { + IsAccessible = true + } + }, { + GroundType.Forest, + new GroundTypeConfig { + IsAccessible = false + } + }, { + GroundType.Castle, + new GroundTypeConfig { + IsAccessible = true + } + } + }; + + + public static Ground Create(GroundType groundType) { + return new Ground(groundType, Configs[groundType].IsAccessible); + } + } +} \ No newline at end of file diff --git a/Model/IBoard.cs b/Model/IBoard.cs new file mode 100644 index 0000000..e94dd47 --- /dev/null +++ b/Model/IBoard.cs @@ -0,0 +1,8 @@ +namespace TradingCompany.Model { + public interface IBoard { + int Rows { get; } + int Columns { get; } + + Field[][] Fields { get; } + } +} \ No newline at end of file diff --git a/Model/IGame.cs b/Model/IGame.cs new file mode 100644 index 0000000..ee2b856 --- /dev/null +++ b/Model/IGame.cs @@ -0,0 +1,6 @@ +namespace TradingCompany.Model { + public interface IGame { + IBoard Board { get; } + + } +} \ No newline at end of file diff --git a/Model/Math/IntVector2.cs b/Model/Math/IntVector2.cs new file mode 100644 index 0000000..3fcb5cb --- /dev/null +++ b/Model/Math/IntVector2.cs @@ -0,0 +1,50 @@ +using System; +using Godot; + +namespace TradingCompany.Model.Math { + public struct IntVector2 : IEquatable { + public static readonly IntVector2 Zero = new IntVector2(0, 0); + public static readonly IntVector2 Up = new IntVector2(0, -1); + public static readonly IntVector2 Down = new IntVector2(0, 1); + public static readonly IntVector2 LeftTop = new IntVector2(-1, 0); + public static readonly IntVector2 LeftBottom = new IntVector2(-1, 1); + public static readonly IntVector2 RightTop = new IntVector2(1, 0); + public static readonly IntVector2 RightBottom = new IntVector2(1, 1); + + public static readonly IntVector2[] HexOffsets = { + Up, LeftTop, LeftBottom, Down, RightBottom, RightTop + }; + + public int x; + public int y; + + public IntVector2(int x, int y) { + this.x = x; + this.y = y; + } + + public bool Equals(IntVector2 other) { + return x == other.x && y == other.y; + } + + public static IntVector2 operator +(IntVector2 left, IntVector2 right) { + left.x += right.x; + left.y += right.y; + return left; + } + + public static IntVector2 operator -(IntVector2 left, IntVector2 right) { + left.x -= right.x; + left.y -= right.y; + return left; + } + + public static IntVector2 FromVector2(Vector2 v) { + return new IntVector2(Mathf.RoundToInt(v.x), Mathf.RoundToInt(v.y)); + } + + public Vector2 ToVector2() { + return new Vector2(x, y); + } + } +} \ No newline at end of file diff --git a/Model/Units/Hero.cs b/Model/Units/Hero.cs new file mode 100644 index 0000000..e550f14 --- /dev/null +++ b/Model/Units/Hero.cs @@ -0,0 +1,7 @@ +using TradingCompany.Model.Math; + +namespace TradingCompany.Model.Units { + public class Hero : IHero { + public IntVector2 Position { get; } + } +} \ No newline at end of file diff --git a/Model/Units/HeroesManager.cs b/Model/Units/HeroesManager.cs new file mode 100644 index 0000000..d13f81e --- /dev/null +++ b/Model/Units/HeroesManager.cs @@ -0,0 +1,11 @@ +using System.Collections.Generic; + +namespace TradingCompany.Model.Units { + public class HeroesManager : IHeroesManager { + public ISet Heroes { get; } + + public HeroesManager(ISet heroes) { + Heroes = heroes; + } + } +} \ No newline at end of file diff --git a/Model/Units/IHero.cs b/Model/Units/IHero.cs new file mode 100644 index 0000000..b6fc982 --- /dev/null +++ b/Model/Units/IHero.cs @@ -0,0 +1,7 @@ +using TradingCompany.Model.Math; + +namespace TradingCompany.Model.Units { + public interface IHero { + IntVector2 Position { get; } + } +} \ No newline at end of file diff --git a/Model/Units/IHeroesManager.cs b/Model/Units/IHeroesManager.cs new file mode 100644 index 0000000..d38eed0 --- /dev/null +++ b/Model/Units/IHeroesManager.cs @@ -0,0 +1,7 @@ +using System.Collections.Generic; + +namespace TradingCompany.Model.Units { + public interface IHeroesManager { + ISet Heroes { get; } + } +} \ No newline at end of file diff --git a/PlayerSupport/ActionPlan.cs b/PlayerSupport/ActionPlan.cs new file mode 100644 index 0000000..249fb90 --- /dev/null +++ b/PlayerSupport/ActionPlan.cs @@ -0,0 +1,25 @@ +using System; +using System.Collections.Generic; +using TradingCompany.Model.Commands; + +namespace TradingCompany.PlayerSupport { + public struct ActionPlan : IEquatable { + public readonly List CommandsSequence; + + public ActionPlan(List commandsSequence) { + CommandsSequence = commandsSequence; + } + + public bool Equals(ActionPlan other) { + return Equals(CommandsSequence, other.CommandsSequence); + } + + public override bool Equals(object obj) { + return obj is ActionPlan other && Equals(other); + } + + public override int GetHashCode() { + return (CommandsSequence != null ? CommandsSequence.GetHashCode() : 0); + } + } +} \ No newline at end of file diff --git a/PlayerSupport/ActionPlanner.cs b/PlayerSupport/ActionPlanner.cs new file mode 100644 index 0000000..abceb83 --- /dev/null +++ b/PlayerSupport/ActionPlanner.cs @@ -0,0 +1,28 @@ +using TradingCompany.Model; +using TradingCompany.Model.Commands; +using TradingCompany.Model.Math; +using TradingCompany.Model.Units; +using TradingCompany.PlayerSupport.Ai.PathFinding; +using TradingCompany.Properties; + +namespace TradingCompany.PlayerSupport { + public static class ActionPlanner { + private static Board _board; + private static PathFinder _pathFinder; + + public static void Initialize(Board board) { + _board = board; + _pathFinder = new PathFinder(board); + } + + public static CommandType GetActionType(IntVector2 position) { + return CommandType.Move; // TODO: Implement + } + + public static ActionPlan GetActionPlan(IHero hero, + IntVector2 targetPosition) { + var path = _pathFinder.FindPath(hero.Position, targetPosition); + return new ActionPlan(path.ConvertAll(position => new Command(position, CommandType.Move))); + } + } +} \ No newline at end of file diff --git a/PlayerSupport/Ai/PathFinding/Node.cs b/PlayerSupport/Ai/PathFinding/Node.cs new file mode 100644 index 0000000..f462b79 --- /dev/null +++ b/PlayerSupport/Ai/PathFinding/Node.cs @@ -0,0 +1,22 @@ +using System.Collections.Generic; +using Godot; + +namespace TradingCompany.Game.Ai.PathFinding +{ + public class Node + { + public readonly List Edges = new List(); + + public Node(Vector2 room) + { + Room = room; + } + + public Room Room { get; } + + public void AddEdge(Edge edge) + { + Edges.Add(edge); + } + } +} \ No newline at end of file diff --git a/PlayerSupport/Ai/PathFinding/PathFinder.cs b/PlayerSupport/Ai/PathFinding/PathFinder.cs new file mode 100644 index 0000000..11735e2 --- /dev/null +++ b/PlayerSupport/Ai/PathFinding/PathFinder.cs @@ -0,0 +1,59 @@ +using System.Collections.Generic; +using TradingCompany.Model; +using TradingCompany.Model.Math; +using TradingCompany.PlayerSupport.Ai.PathFinding.PriorityQueues; + +namespace TradingCompany.PlayerSupport.Ai.PathFinding { + public class PathFinder { + private readonly int _columns; + private readonly int _rows; + private readonly byte[][][] _weights; + + public PathFinder(IBoard board) { + _weights = WeightsFactory.Create(board); + _rows = board.Rows; + _columns = board.Columns; + } + + public List FindPath(IntVector2 from, IntVector2 to) { + var priorityQueue = new PriorityQueue(_weights.GetLength(0) * _weights.GetLength(1)); + + priorityQueue.Enqueue(from, 0, new IntVector2(-1, -1)); + while (priorityQueue.Count > 0) { + var currentEntry = priorityQueue.Dequeue(); + var currentPosition = currentEntry.Position; + for (var offsetIndex = 0; offsetIndex < IntVector2.HexOffsets.Length; offsetIndex++) { + var weight = _weights[currentPosition.y][currentPosition.x][offsetIndex]; + if (weight > 0) { + var neighborPosition = currentPosition + IntVector2.HexOffsets[offsetIndex]; + if (!priorityQueue.HasBeenEnqueued(neighborPosition)) { + priorityQueue.Enqueue(neighborPosition, currentEntry.Weight + weight, + currentPosition); + } + else { + if (priorityQueue.Get(neighborPosition).Weight > currentEntry.Weight + weight) { + priorityQueue.DecreaseWeight(neighborPosition, currentEntry.Weight + weight, + currentPosition); + } + } + } + } + } + + return priorityQueue.HasBeenEnqueued(to) + ? RecreatePath(priorityQueue.Get(to), priorityQueue) + : null; + } + + private List RecreatePath(WeightedNode weightedNode, PriorityQueue priorityQueue) { + var path = new List(); + while (weightedNode != null) { + path.Add(weightedNode.LastVisitedFrom); + weightedNode = priorityQueue.Get(weightedNode.LastVisitedFrom); + } + + path.Reverse(); + return path; + } + } +} \ No newline at end of file diff --git a/PlayerSupport/Ai/PathFinding/PriorityQueues/PriorityQueue.cs b/PlayerSupport/Ai/PathFinding/PriorityQueues/PriorityQueue.cs new file mode 100644 index 0000000..00d94ee --- /dev/null +++ b/PlayerSupport/Ai/PathFinding/PriorityQueues/PriorityQueue.cs @@ -0,0 +1,75 @@ +using System; +using System.Collections.Generic; +using TradingCompany.Model.Math; + +namespace TradingCompany.PlayerSupport.Ai.PathFinding.PriorityQueues { + public class PriorityQueue { + private readonly WeightedNode[] _positions; + + private readonly Dictionary _weightedNodes = + new Dictionary(); + + public PriorityQueue(int totalNodesCount) { + _positions = new WeightedNode[totalNodesCount]; + } + + public int Count { get; private set; } + + public void Enqueue(IntVector2 position, int initialWeight, IntVector2 initiallyVisitedFrom) { + if (_weightedNodes.ContainsKey(position)) { + throw new ApplicationException("Cannot register Node twice"); + } + + _positions[Count] = new WeightedNode(position, initialWeight, Count, initiallyVisitedFrom); + _weightedNodes[position] = _positions[Count]; + Count++; + SortUp(Count); + } + + public WeightedNode Dequeue() { + Swap(0, Count - 1); + Count--; + SortDown(0); + return _positions[Count]; + } + + public bool HasBeenEnqueued(IntVector2 position) { + return _weightedNodes.ContainsKey(position); + } + + public WeightedNode Get(IntVector2 position) { + return _weightedNodes[position]; + } + + public void DecreaseWeight(IntVector2 position, int newWeight, IntVector2 lastVisitedFrom) { + _weightedNodes[position].Weight = newWeight; + _weightedNodes[position].LastVisitedFrom = lastVisitedFrom; + SortUp(_weightedNodes[position].Index); + } + + private void SortUp(int positionIndex) { + while (positionIndex > 0 && _positions[positionIndex].Weight < _positions[positionIndex / 2].Weight) { + Swap(positionIndex, positionIndex / 2); + positionIndex /= 2; + } + } + + private void SortDown(int positionIndex) { + while (positionIndex * 2 + 1 < Count) { + var minIndex = _positions[positionIndex * 2 + 1].Weight <= _positions[positionIndex * 2 + 2].Weight + ? positionIndex * 2 + 1 + : positionIndex * 2 + 2; + Swap(positionIndex, minIndex); + positionIndex /= minIndex; + } + } + + private void Swap(int index1, int index2) { + var temp = _positions[index1]; + _positions[index1] = _positions[index2]; + _positions[index2] = temp; + _weightedNodes[_positions[index1].Position].Index = index1; + _weightedNodes[_positions[index2].Position].Index = index2; + } + } +} \ No newline at end of file diff --git a/PlayerSupport/Ai/PathFinding/PriorityQueues/WeightedNode.cs b/PlayerSupport/Ai/PathFinding/PriorityQueues/WeightedNode.cs new file mode 100644 index 0000000..ce4cfcb --- /dev/null +++ b/PlayerSupport/Ai/PathFinding/PriorityQueues/WeightedNode.cs @@ -0,0 +1,17 @@ +using TradingCompany.Model.Math; + +namespace TradingCompany.PlayerSupport.Ai.PathFinding.PriorityQueues { + public class WeightedNode { + public WeightedNode(IntVector2 position, int initialWeight, int initialIndex, IntVector2 lastVisitedFrom) { + Position = position; + Weight = initialWeight; + Index = initialIndex; + LastVisitedFrom = lastVisitedFrom; + } + + public IntVector2 Position { get; } + public int Weight { get; set; } + public int Index { get; set; } + public IntVector2 LastVisitedFrom { get; set; } + } +} \ No newline at end of file diff --git a/PlayerSupport/Ai/PathFinding/WeightsFactory.cs b/PlayerSupport/Ai/PathFinding/WeightsFactory.cs new file mode 100644 index 0000000..dd943e9 --- /dev/null +++ b/PlayerSupport/Ai/PathFinding/WeightsFactory.cs @@ -0,0 +1,36 @@ +using TradingCompany.Model; +using TradingCompany.Model.Math; + +namespace TradingCompany.PlayerSupport.Ai.PathFinding { + public static class WeightsFactory { + public static byte[][][] Create(IBoard board) { + var weights = new byte[board.Rows][][]; + for (var row = 0; row < board.Rows; row++) { + weights[row] = new byte[board.Columns][]; + for (var column = 0; row < board.Columns; row++) { + weights[row][column] = new byte[IntVector2.HexOffsets.Length]; + var currentPosition = new IntVector2(column, row); + for (var offsetIndex = 0; offsetIndex < IntVector2.HexOffsets.Length; offsetIndex++) { + var neighborPosition = currentPosition + IntVector2.HexOffsets[offsetIndex]; + weights[row][column][offsetIndex] = IsPositionOnBoard(neighborPosition, board) + && board.Fields[row][column].Ground.IsAccessible + ? (byte) 1 + : (byte) 0; + } + + foreach (var offset in IntVector2.HexOffsets) { + } + } + } + + return weights; + } + + private static bool IsPositionOnBoard(IntVector2 position, IBoard board) { + return position.x >= 0 + && position.x < board.Columns + && position.y >= 0 + && position.y < board.Rows; + } + } +} \ No newline at end of file diff --git a/Properties/Annotations.cs b/Properties/Annotations.cs new file mode 100644 index 0000000..bc9be79 --- /dev/null +++ b/Properties/Annotations.cs @@ -0,0 +1,1239 @@ +/* MIT License + +Copyright (c) 2016 JetBrains http://www.jetbrains.com + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. */ + +using System; + +// ReSharper disable InheritdocConsiderUsage + +#pragma warning disable 1591 +// ReSharper disable UnusedMember.Global +// ReSharper disable MemberCanBePrivate.Global +// ReSharper disable UnusedAutoPropertyAccessor.Global +// ReSharper disable IntroduceOptionalParameters.Global +// ReSharper disable MemberCanBeProtected.Global +// ReSharper disable InconsistentNaming + +namespace TradingCompany.Properties { + /// + /// Indicates that the value of the marked element could be null sometimes, + /// so checking for null is required before its usage. + /// + /// + /// + /// [CanBeNull] object Test() => null; + /// + /// void UseTest() { + /// var p = Test(); + /// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException' + /// } + /// + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)] + public sealed class CanBeNullAttribute : Attribute { + } + + /// + /// Indicates that the value of the marked element can never be null. + /// + /// + /// + /// [NotNull] object Foo() { + /// return null; // Warning: Possible 'null' assignment + /// } + /// + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)] + public sealed class NotNullAttribute : Attribute { + } + + /// + /// Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can never be null. + /// + /// + /// + /// public void Foo([ItemNotNull]List<string> books) + /// { + /// foreach (var book in books) { + /// if (book != null) // Warning: Expression is always true + /// Console.WriteLine(book.ToUpper()); + /// } + /// } + /// + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + public sealed class ItemNotNullAttribute : Attribute { + } + + /// + /// Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can be null. + /// + /// + /// + /// public void Foo([ItemCanBeNull]List<string> books) + /// { + /// foreach (var book in books) + /// { + /// // Warning: Possible 'System.NullReferenceException' + /// Console.WriteLine(book.ToUpper()); + /// } + /// } + /// + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + public sealed class ItemCanBeNullAttribute : Attribute { + } + + /// + /// Indicates that the marked method builds string by the format pattern and (optional) arguments. + /// The parameter, which contains the format string, should be given in constructor. The format string + /// should be in -like form. + /// + /// + /// + /// [StringFormatMethod("message")] + /// void ShowError(string message, params object[] args) { /* do something */ } + /// + /// void Foo() { + /// ShowError("Failed: {0}"); // Warning: Non-existing argument in format string + /// } + /// + /// + [AttributeUsage( + AttributeTargets.Constructor | AttributeTargets.Method | + AttributeTargets.Property | AttributeTargets.Delegate)] + public sealed class StringFormatMethodAttribute : Attribute { + /// + /// Specifies which parameter of an annotated method should be treated as the format string + /// + public StringFormatMethodAttribute([NotNull] string formatParameterName) { + FormatParameterName = formatParameterName; + } + + [NotNull] public string FormatParameterName { get; } + } + + /// + /// Use this annotation to specify a type that contains static or const fields + /// with values for the annotated property/field/parameter. + /// The specified type will be used to improve completion suggestions. + /// + /// + /// + /// namespace TestNamespace + /// { + /// public class Constants + /// { + /// public static int INT_CONST = 1; + /// public const string STRING_CONST = "1"; + /// } + /// + /// public class Class1 + /// { + /// [ValueProvider("TestNamespace.Constants")] public int myField; + /// public void Foo([ValueProvider("TestNamespace.Constants")] string str) { } + /// + /// public void Test() + /// { + /// Foo(/*try completion here*/);// + /// myField = /*try completion here*/ + /// } + /// } + /// } + /// + /// + [AttributeUsage( + AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field, + AllowMultiple = true)] + public sealed class ValueProviderAttribute : Attribute { + public ValueProviderAttribute([NotNull] string name) { + Name = name; + } + + [NotNull] public string Name { get; } + } + + /// + /// Indicates that the function argument should be a string literal and match one + /// of the parameters of the caller function. For example, ReSharper annotates + /// the parameter of . + /// + /// + /// + /// void Foo(string param) { + /// if (param == null) + /// throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class InvokerParameterNameAttribute : Attribute { + } + + /// + /// Indicates that the method is contained in a type that implements + /// System.ComponentModel.INotifyPropertyChanged interface and this method + /// is used to notify that some property value changed. + /// + /// + /// The method should be non-static and conform to one of the supported signatures: + /// + /// + /// NotifyChanged(string) + /// + /// + /// NotifyChanged(params string[]) + /// + /// + /// NotifyChanged{T}(Expression{Func{T}}) + /// + /// + /// NotifyChanged{T,U}(Expression{Func{T,U}}) + /// + /// + /// SetProperty{T}(ref T, T, string) + /// + /// + /// + /// + /// + /// public class Foo : INotifyPropertyChanged { + /// public event PropertyChangedEventHandler PropertyChanged; + /// + /// [NotifyPropertyChangedInvocator] + /// protected virtual void NotifyChanged(string propertyName) { ... } + /// + /// string _name; + /// + /// public string Name { + /// get { return _name; } + /// set { _name = value; NotifyChanged("LastName"); /* Warning */ } + /// } + /// } + /// + /// Examples of generated notifications: + /// + /// + /// NotifyChanged("Property") + /// + /// + /// NotifyChanged(() => Property) + /// + /// + /// NotifyChanged((VM x) => x.Property) + /// + /// + /// SetProperty(ref myField, value, "Property") + /// + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute { + public NotifyPropertyChangedInvocatorAttribute() { + } + + public NotifyPropertyChangedInvocatorAttribute([NotNull] string parameterName) { + ParameterName = parameterName; + } + + [CanBeNull] public string ParameterName { get; } + } + + /// + /// Describes dependency between method input and output. + /// + /// + ///

Function Definition Table syntax:

+ /// + /// FDT ::= FDTRow [;FDTRow]* + /// FDTRow ::= Input => Output | Output <= Input + /// Input ::= ParameterName: Value [, Input]* + /// Output ::= [ParameterName: Value]* {halt|stop|void|nothing|Value} + /// Value ::= true | false | null | notnull | canbenull + /// + /// If the method has a single input parameter, its name could be omitted.
+ /// Using halt (or void/nothing, which is the same) for the method output + /// means that the method doesn't return normally (throws or terminates the process).
+ /// Value canbenull is only applicable for output parameters.
+ /// You can use multiple [ContractAnnotation] for each FDT row, or use single attribute + /// with rows separated by semicolon. There is no notion of order rows, all rows are checked + /// for applicability and applied per each program state tracked by the analysis engine.
+ /// + /// + /// + /// + /// + /// [ContractAnnotation("=> halt")] + /// public void TerminationMethod() + /// + /// + /// + /// + /// [ContractAnnotation("null <= param:null")] // reverse condition syntax + /// public string GetName(string surname) + /// + /// + /// + /// + /// [ContractAnnotation("s:null => true")] + /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty() + /// + /// + /// + /// + /// // A method that returns null if the parameter is null, + /// // and not null if the parameter is not null + /// [ContractAnnotation("null => null; notnull => notnull")] + /// public object Transform(object data) + /// + /// + /// + /// + /// [ContractAnnotation("=> true, result: notnull; => false, result: null")] + /// public bool TryParse(string s, out Person result) + /// + /// + /// + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] + public sealed class ContractAnnotationAttribute : Attribute { + public ContractAnnotationAttribute([NotNull] string contract) + : this(contract, false) { + } + + public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates) { + Contract = contract; + ForceFullStates = forceFullStates; + } + + [NotNull] public string Contract { get; } + + public bool ForceFullStates { get; } + } + + /// + /// Indicates whether the marked element should be localized. + /// + /// + /// + /// [LocalizationRequiredAttribute(true)] + /// class Foo { + /// string str = "my string"; // Warning: Localizable string + /// } + /// + /// + [AttributeUsage(AttributeTargets.All)] + public sealed class LocalizationRequiredAttribute : Attribute { + public LocalizationRequiredAttribute() : this(true) { + } + + public LocalizationRequiredAttribute(bool required) { + Required = required; + } + + public bool Required { get; } + } + + /// + /// Indicates that the value of the marked type (or its derivatives) + /// cannot be compared using '==' or '!=' operators and Equals() + /// should be used instead. However, using '==' or '!=' for comparison + /// with null is always permitted. + /// + /// + /// + /// [CannotApplyEqualityOperator] + /// class NoEquality { } + /// + /// class UsesNoEquality { + /// void Test() { + /// var ca1 = new NoEquality(); + /// var ca2 = new NoEquality(); + /// if (ca1 != null) { // OK + /// bool condition = ca1 == ca2; // Warning + /// } + /// } + /// } + /// + /// + [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)] + public sealed class CannotApplyEqualityOperatorAttribute : Attribute { + } + + /// + /// When applied to a target attribute, specifies a requirement for any type marked + /// with the target attribute to implement or inherit specific type or types. + /// + /// + /// + /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement + /// class ComponentAttribute : Attribute { } + /// + /// [Component] // ComponentAttribute requires implementing IComponent interface + /// class MyComponent : IComponent { } + /// + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + [BaseTypeRequired(typeof(Attribute))] + public sealed class BaseTypeRequiredAttribute : Attribute { + public BaseTypeRequiredAttribute([NotNull] Type baseType) { + BaseType = baseType; + } + + [NotNull] public Type BaseType { get; } + } + + /// + /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), + /// so this symbol will not be reported as unused (as well as by other usage inspections). + /// + [AttributeUsage(AttributeTargets.All)] + public sealed class UsedImplicitlyAttribute : Attribute { + public UsedImplicitlyAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { + } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { + } + + public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { + } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + public ImplicitUseKindFlags UseKindFlags { get; } + + public ImplicitUseTargetFlags TargetFlags { get; } + } + + /// + /// Can be applied to attributes, type parameters, and parameters of a type assignable from + /// . + /// When applied to an attribute, the decorated attribute behaves the same as . + /// When applied to a type parameter or to a parameter of type , indicates that the + /// corresponding type + /// is used implicitly. + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter | AttributeTargets.Parameter)] + public sealed class MeansImplicitUseAttribute : Attribute { + public MeansImplicitUseAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { + } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { + } + + public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { + } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; } + + [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; } + } + + /// + /// Specify the details of implicitly used symbol when it is marked + /// with or . + /// + [Flags] + public enum ImplicitUseKindFlags { + Default = Access | Assign | InstantiatedWithFixedConstructorSignature, + + /// Only entity marked with attribute considered used. + Access = 1, + + /// Indicates implicit assignment to a member. + Assign = 2, + + /// + /// Indicates implicit instantiation of a type with fixed constructor signature. + /// That means any unused constructor parameters won't be reported as such. + /// + InstantiatedWithFixedConstructorSignature = 4, + + /// Indicates implicit instantiation of a type. + InstantiatedNoFixedConstructorSignature = 8 + } + + /// + /// Specify what is considered to be used implicitly when marked + /// with or . + /// + [Flags] + public enum ImplicitUseTargetFlags { + Default = Itself, + Itself = 1, + + /// Members of entity marked with attribute are considered used. + Members = 2, + + /// Entity marked with attribute and all its members considered used. + WithMembers = Itself | Members + } + + /// + /// This attribute is intended to mark publicly available API + /// which should not be removed and so is treated as used. + /// + [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)] + public sealed class PublicAPIAttribute : Attribute { + public PublicAPIAttribute() { + } + + public PublicAPIAttribute([NotNull] string comment) { + Comment = comment; + } + + [CanBeNull] public string Comment { get; } + } + + /// + /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack. + /// If the parameter is a delegate, indicates that delegate is executed while the method is executed. + /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class InstantHandleAttribute : Attribute { + } + + /// + /// Indicates that a method does not make any observable state changes. + /// The same as System.Diagnostics.Contracts.PureAttribute. + /// + /// + /// + /// [Pure] int Multiply(int x, int y) => x * y; + /// + /// void M() { + /// Multiply(123, 42); // Waring: Return value of pure method is not used + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class PureAttribute : Attribute { + } + + /// + /// Indicates that the return value of the method invocation must be used. + /// + /// + /// Methods decorated with this attribute (in contrast to pure methods) might change state, + /// but make no sense without using their return value.
+ /// Similarly to , this attribute + /// will help detecting usages of the method when the return value in not used. + /// Additionally, you can optionally specify a custom message, which will be used when showing warnings, e.g. + /// [MustUseReturnValue("Use the return value to...")]. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class MustUseReturnValueAttribute : Attribute { + public MustUseReturnValueAttribute() { + } + + public MustUseReturnValueAttribute([NotNull] string justification) { + Justification = justification; + } + + [CanBeNull] public string Justification { get; } + } + + /// + /// Indicates the type member or parameter of some type, that should be used instead of all other ways + /// to get the value of that type. This annotation is useful when you have some "context" value evaluated + /// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one. + /// + /// + /// + /// class Foo { + /// [ProvidesContext] IBarService _barService = ...; + /// + /// void ProcessNode(INode node) { + /// DoSomething(node, node.GetGlobalServices().Bar); + /// // ^ Warning: use value of '_barService' field + /// } + /// } + /// + /// + [AttributeUsage( + AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Method | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | + AttributeTargets.GenericParameter)] + public sealed class ProvidesContextAttribute : Attribute { + } + + /// + /// Indicates that a parameter is a path to a file or a folder within a web project. + /// Path can be relative or absolute, starting from web root (~). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class PathReferenceAttribute : Attribute { + public PathReferenceAttribute() { + } + + public PathReferenceAttribute([NotNull] [PathReference] string basePath) { + BasePath = basePath; + } + + [CanBeNull] public string BasePath { get; } + } + + /// + /// An extension method marked with this attribute is processed by code completion + /// as a 'Source Template'. When the extension method is completed over some expression, its source code + /// is automatically expanded like a template at call site. + /// + /// + /// Template method body can contain valid source code and/or special comments starting with '$'. + /// Text inside these comments is added as source code when the template is applied. Template parameters + /// can be used either as additional method parameters or as identifiers wrapped in two '$' signs. + /// Use the attribute to specify macros for parameters. + /// + /// + /// In this example, the 'forEach' method is a source template available over all values + /// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block: + /// + /// [SourceTemplate] + /// public static void forEach<T>(this IEnumerable<T> xs) { + /// foreach (var x in xs) { + /// //$ $END$ + /// } + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class SourceTemplateAttribute : Attribute { + } + + /// + /// Allows specifying a macro for a parameter of a source template. + /// + /// + /// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression + /// is defined in the property. When applied on a method, the target + /// template parameter is defined in the property. To apply the macro silently + /// for the parameter, set the property value = -1. + /// + /// + /// Applying the attribute on a source template method: + /// + /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")] + /// public static void forEach<T>(this IEnumerable<T> collection) { + /// foreach (var item in collection) { + /// //$ $END$ + /// } + /// } + /// + /// Applying the attribute on a template method parameter: + /// + /// [SourceTemplate] + /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) { + /// /*$ var $x$Id = "$newguid$" + x.ToString(); + /// x.DoSomething($x$Id); */ + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)] + public sealed class MacroAttribute : Attribute { + /// + /// Allows specifying a macro that will be executed for a source template + /// parameter when the template is expanded. + /// + [CanBeNull] + public string Expression { get; set; } + + /// + /// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed. + /// + /// + /// If the target parameter is used several times in the template, only one occurrence becomes editable; + /// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence, + /// use values >= 0. To make the parameter non-editable when the template is expanded, use -1. + /// + public int Editable { get; set; } + + /// + /// Identifies the target parameter of a source template if the + /// is applied on a template method. + /// + [CanBeNull] + public string Target { get; set; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = + true)] + public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute { + public AspMvcAreaMasterLocationFormatAttribute([NotNull] string format) { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = + true)] + public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute { + public AspMvcAreaPartialViewLocationFormatAttribute([NotNull] string format) { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = + true)] + public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute { + public AspMvcAreaViewLocationFormatAttribute([NotNull] string format) { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = + true)] + public sealed class AspMvcMasterLocationFormatAttribute : Attribute { + public AspMvcMasterLocationFormatAttribute([NotNull] string format) { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = + true)] + public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute { + public AspMvcPartialViewLocationFormatAttribute([NotNull] string format) { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = + true)] + public sealed class AspMvcViewLocationFormatAttribute : Attribute { + public AspMvcViewLocationFormatAttribute([NotNull] string format) { + Format = format; + } + + [NotNull] public string Format { get; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC action. If applied to a method, the MVC action name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | + AttributeTargets.Property)] + public sealed class AspMvcActionAttribute : Attribute { + public AspMvcActionAttribute() { + } + + public AspMvcActionAttribute([NotNull] string anonymousProperty) { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] public string AnonymousProperty { get; } + } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC area. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcAreaAttribute : Attribute { + public AspMvcAreaAttribute() { + } + + public AspMvcAreaAttribute([NotNull] string anonymousProperty) { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] public string AnonymousProperty { get; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is + /// an MVC controller. If applied to a method, the MVC controller name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | + AttributeTargets.Property)] + public sealed class AspMvcControllerAttribute : Attribute { + public AspMvcControllerAttribute() { + } + + public AspMvcControllerAttribute([NotNull] string anonymousProperty) { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] public string AnonymousProperty { get; } + } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC Master. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcMasterAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC model type. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, Object). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcModelTypeAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC + /// partial view. If applied to a method, the MVC partial view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | + AttributeTargets.Property)] + public sealed class AspMvcPartialViewAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method. + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] + public sealed class AspMvcSuppressViewErrorAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcDisplayTemplateAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC editor template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcEditorTemplateAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC template. + /// Use this attribute for custom wrappers similar to + /// System.ComponentModel.DataAnnotations.UIHintAttribute(System.String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcTemplateAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Controller.View(Object). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | + AttributeTargets.Property)] + public sealed class AspMvcViewAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component name. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcViewComponentAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component view. If applied to a method, the MVC view component view name is default. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | + AttributeTargets.Property)] + public sealed class AspMvcViewComponentViewAttribute : Attribute { + } + + /// + /// ASP.NET MVC attribute. When applied to a parameter of an attribute, + /// indicates that this parameter is an MVC action name. + /// + /// + /// + /// [ActionName("Foo")] + /// public ActionResult Login(string returnUrl) { + /// ViewBag.ReturnUrl = Url.Action("Foo"); // OK + /// return RedirectToAction("Bar"); // Error: Cannot resolve action + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)] + public sealed class AspMvcActionSelectorAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)] + public sealed class HtmlElementAttributesAttribute : Attribute { + public HtmlElementAttributesAttribute() { + } + + public HtmlElementAttributesAttribute([NotNull] string name) { + Name = name; + } + + [CanBeNull] public string Name { get; } + } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class HtmlAttributeValueAttribute : Attribute { + public HtmlAttributeValueAttribute([NotNull] string name) { + Name = name; + } + + [NotNull] public string Name { get; } + } + + /// + /// Razor attribute. Indicates that the marked parameter or method is a Razor section. + /// Use this attribute for custom wrappers similar to + /// System.Web.WebPages.WebPageBase.RenderSection(String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class RazorSectionAttribute : Attribute { + } + + /// + /// Indicates how method, constructor invocation, or property access + /// over collection type affects the contents of the collection. + /// Use to specify the access type. + /// + /// + /// Using this attribute only makes sense if all collection methods are marked with this attribute. + /// + /// + /// + /// public class MyStringCollection : List<string> + /// { + /// [CollectionAccess(CollectionAccessType.Read)] + /// public string GetFirstString() + /// { + /// return this.ElementAt(0); + /// } + /// } + /// class Test + /// { + /// public void Foo() + /// { + /// // Warning: Contents of the collection is never updated + /// var col = new MyStringCollection(); + /// string x = col.GetFirstString(); + /// } + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)] + public sealed class CollectionAccessAttribute : Attribute { + public CollectionAccessAttribute(CollectionAccessType collectionAccessType) { + CollectionAccessType = collectionAccessType; + } + + public CollectionAccessType CollectionAccessType { get; } + } + + /// + /// Provides a value for the to define + /// how the collection method invocation affects the contents of the collection. + /// + [Flags] + public enum CollectionAccessType { + /// Method does not use or modify content of the collection. + None = 0, + + /// Method only reads content of the collection but does not modify it. + Read = 1, + + /// Method can change content of the collection but does not add new elements. + ModifyExistingContent = 2, + + /// Method can add new elements to the collection. + UpdatedContent = ModifyExistingContent | 4 + } + + /// + /// Indicates that the marked method is assertion method, i.e. it halts the control flow if + /// one of the conditions is satisfied. To set the condition, mark one of the parameters with + /// attribute. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class AssertionMethodAttribute : Attribute { + } + + /// + /// Indicates the condition parameter of the assertion method. The method itself should be + /// marked by attribute. The mandatory argument of + /// the attribute is the assertion type. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AssertionConditionAttribute : Attribute { + public AssertionConditionAttribute(AssertionConditionType conditionType) { + ConditionType = conditionType; + } + + public AssertionConditionType ConditionType { get; } + } + + /// + /// Specifies assertion type. If the assertion method argument satisfies the condition, + /// then the execution continues. Otherwise, execution is assumed to be halted. + /// + public enum AssertionConditionType { + /// Marked parameter should be evaluated to true. + IS_TRUE = 0, + + /// Marked parameter should be evaluated to false. + IS_FALSE = 1, + + /// Marked parameter should be evaluated to null value. + IS_NULL = 2, + + /// Marked parameter should be evaluated to not null value. + IS_NOT_NULL = 3 + } + + /// + /// Indicates that the marked method unconditionally terminates control flow execution. + /// For example, it could unconditionally throw exception. + /// + [Obsolete("Use [ContractAnnotation('=> halt')] instead")] + [AttributeUsage(AttributeTargets.Method)] + public sealed class TerminatesProgramAttribute : Attribute { + } + + /// + /// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select, + /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters + /// of delegate type by analyzing LINQ method chains. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class LinqTunnelAttribute : Attribute { + } + + /// + /// Indicates that IEnumerable passed as a parameter is not enumerated. + /// Use this annotation to suppress the 'Possible multiple enumeration of IEnumerable' inspection. + /// + /// + /// + /// static void ThrowIfNull<T>([NoEnumeration] T v, string n) where T : class + /// { + /// // custom check for null but no enumeration + /// } + /// + /// void Foo(IEnumerable<string> values) + /// { + /// ThrowIfNull(values, nameof(values)); + /// var x = values.ToList(); // No warnings about multiple enumeration + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class NoEnumerationAttribute : Attribute { + } + + /// + /// Indicates that the marked parameter is a regular expression pattern. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class RegexPatternAttribute : Attribute { + } + + /// + /// Prevents the Member Reordering feature from tossing members of the marked class. + /// + /// + /// The attribute must be mentioned in your member reordering patterns. + /// + [AttributeUsage( + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.Enum)] + public sealed class NoReorderAttribute : Attribute { + } + + /// + /// XAML attribute. Indicates the type that has ItemsSource property and should be treated + /// as ItemsControl-derived type, to enable inner items DataContext type resolve. + /// + [AttributeUsage(AttributeTargets.Class)] + public sealed class XamlItemsControlAttribute : Attribute { + } + + /// + /// XAML attribute. Indicates the property of some BindingBase-derived type, that + /// is used to bind some item of ItemsControl-derived type. This annotation will + /// enable the DataContext type resolve for XAML bindings for such properties. + /// + /// + /// Property should have the tree ancestor of the ItemsControl type or + /// marked with the attribute. + /// + [AttributeUsage(AttributeTargets.Property)] + public sealed class XamlItemBindingOfItemsControlAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class AspChildControlTypeAttribute : Attribute { + public AspChildControlTypeAttribute([NotNull] string tagName, [NotNull] Type controlType) { + TagName = tagName; + ControlType = controlType; + } + + [NotNull] public string TagName { get; } + + [NotNull] public Type ControlType { get; } + } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + public sealed class AspDataFieldAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + public sealed class AspDataFieldsAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class AspMethodPropertyAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class AspRequiredAttributeAttribute : Attribute { + public AspRequiredAttributeAttribute([NotNull] string attribute) { + Attribute = attribute; + } + + [NotNull] public string Attribute { get; } + } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class AspTypePropertyAttribute : Attribute { + public AspTypePropertyAttribute(bool createConstructorReferences) { + CreateConstructorReferences = createConstructorReferences; + } + + public bool CreateConstructorReferences { get; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorImportNamespaceAttribute : Attribute { + public RazorImportNamespaceAttribute([NotNull] string name) { + Name = name; + } + + [NotNull] public string Name { get; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorInjectionAttribute : Attribute { + public RazorInjectionAttribute([NotNull] string type, [NotNull] string fieldName) { + Type = type; + FieldName = fieldName; + } + + [NotNull] public string Type { get; } + + [NotNull] public string FieldName { get; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorDirectiveAttribute : Attribute { + public RazorDirectiveAttribute([NotNull] string directive) { + Directive = directive; + } + + [NotNull] public string Directive { get; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorPageBaseTypeAttribute : Attribute { + public RazorPageBaseTypeAttribute([NotNull] string baseType) { + BaseType = baseType; + } + + public RazorPageBaseTypeAttribute([NotNull] string baseType, string pageName) { + BaseType = baseType; + PageName = pageName; + } + + [NotNull] public string BaseType { get; } + [CanBeNull] public string PageName { get; } + } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorHelperCommonAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class RazorLayoutAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorWriteLiteralMethodAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorWriteMethodAttribute : Attribute { + } + + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class RazorWriteMethodParameterAttribute : Attribute { + } +} \ No newline at end of file diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..114d0d4 --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,25 @@ +using System.Reflection; + +// Information about this assembly is defined by the following attributes. +// Change them to the values specific to your project. + +[assembly: AssemblyTitle("TradingCompany")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("")] +[assembly: AssemblyCopyright("")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}". +// The form "{Major}.{Minor}.*" will automatically update the build and revision, +// and "{Major}.{Minor}.{Build}.*" will update just the revision. + +[assembly: AssemblyVersion("1.0.*")] + +// The following attributes are used to specify the signing key for the assembly, +// if desired. See the Mono documentation for more information about signing. + +//[assembly: AssemblyDelaySign(false)] +//[assembly: AssemblyKeyFile("")] \ No newline at end of file diff --git a/Shaders/Highlight.shader b/Shaders/Highlight.shader new file mode 100644 index 0000000..d47a054 --- /dev/null +++ b/Shaders/Highlight.shader @@ -0,0 +1,39 @@ +shader_type canvas_item; +render_mode unshaded; + +uniform int intensity : hint_range(0,200); +uniform float precision : hint_range(0,0.02); +uniform vec4 outline_color : hint_color; + +varying vec2 o; +varying vec2 f; + +void vertex() +{ + o = VERTEX; + vec2 uv = (UV - 0.5); + VERTEX += uv * float(intensity); + f = VERTEX; +} + +void fragment() +{ + ivec2 t = textureSize(TEXTURE, 0); + vec2 regular_uv; + regular_uv.x = UV.x + (f.x - o.x)/float(t.x); + regular_uv.y = UV.y + (f.y - o.y)/float(t.y); + + vec4 regular_color = texture(TEXTURE, regular_uv); + if((regular_uv.x < 0.0 || regular_uv.x > 1.0) || (regular_uv.y < 0.0 || regular_uv.y > 1.0) || regular_color.a <=0.25){ + regular_color = vec4(0.0); + } + + vec2 ps = TEXTURE_PIXEL_SIZE * float(intensity) * precision; + + COLOR = vec4(0); + if (regular_color.r <= 0f + && regular_color.g <= 0f + && regular_color.b <= 0f) { + COLOR = vec4(outline_color.rgb, regular_color.a); + } +} \ No newline at end of file diff --git a/Shaders/HighlightMaterial.tres b/Shaders/HighlightMaterial.tres new file mode 100644 index 0000000..97d1c2d --- /dev/null +++ b/Shaders/HighlightMaterial.tres @@ -0,0 +1,10 @@ +[gd_resource type="ShaderMaterial" load_steps=2 format=2] + +[ext_resource path="res://Shaders/Highlight.shader" type="Shader" id=1] + +[resource] +render_priority = 5 +shader = ExtResource( 1 ) +shader_param/intensity = null +shader_param/precision = null +shader_param/outline_color = Color( 0.878431, 0.00392157, 0.00392157, 1 ) diff --git a/Shaders/SelectionMaterial.tres b/Shaders/SelectionMaterial.tres new file mode 100644 index 0000000..49b34d0 --- /dev/null +++ b/Shaders/SelectionMaterial.tres @@ -0,0 +1,10 @@ +[gd_resource type="ShaderMaterial" load_steps=2 format=2] + +[ext_resource path="res://Shaders/Highlight.shader" type="Shader" id=1] + +[resource] +render_priority = 4 +shader = ExtResource( 1 ) +shader_param/intensity = null +shader_param/precision = null +shader_param/outline_color = Color( 0.886275, 0.886275, 0.886275, 1 ) diff --git a/Stage.tscn b/Stage.tscn new file mode 100644 index 0000000..70057be --- /dev/null +++ b/Stage.tscn @@ -0,0 +1,70 @@ +[gd_scene load_steps=10 format=2] + +[ext_resource path="res://Images/Grounds/ground_tile_set.tres" type="TileSet" id=1] +[ext_resource path="res://View/Board/BoardController.cs" type="Script" id=2] +[ext_resource path="res://Shaders/HighlightMaterial.tres" type="Material" id=3] +[ext_resource path="res://View/Highlighting/TilesHighlightingLayer.cs" type="Script" id=4] +[ext_resource path="res://View/Highlighting/HighlightingController.cs" type="Script" id=5] +[ext_resource path="res://Shaders/SelectionMaterial.tres" type="Material" id=6] +[ext_resource path="res://View/Selection/TilesSelectionLayer.cs" type="Script" id=7] +[ext_resource path="res://Images/Characters/knecht.tres" type="Texture" id=8] +[ext_resource path="res://View/Input/MouseController.cs" type="Script" id=9] + +[node name="Stage2D" type="Node2D"] + +[node name="Board" type="Node" parent="."] + +[node name="Ground" type="TileMap" parent="Board"] +tile_set = ExtResource( 1 ) +cell_size = Vector2( 24, 24 ) +cell_half_offset = 1 +cell_y_sort = true +format = 1 +tile_data = PoolIntArray( 0, 0, 2, 1, 0, 2, 2, 0, 2, 3, 0, 2, 4, 0, 1, 5, 0, 2, 6, 0, 2, 7, 0, 1, 8, 0, 1, 9, 0, 1, 10, 0, 1, 11, 0, 1, 12, 0, 1, 13, 0, 1, 14, 0, 1, 15, 0, 1, 16, 0, 1, 17, 0, 1, 18, 0, 1, 19, 0, 1, 20, 0, 1, 21, 0, 1, 22, 0, 1, 23, 0, 1, 24, 0, 1, 25, 0, 1, 26, 0, 1, 27, 0, 1, 28, 0, 1, 29, 0, 1, 30, 0, 1, 31, 0, 1, 65536, 0, 2, 65537, 0, 2, 65538, 0, 2, 65539, 0, 1, 65540, 0, 1, 65541, 0, 1, 65542, 0, 1, 65543, 0, 1, 65544, 0, 1, 65545, 0, 1, 65546, 0, 1, 65547, 0, 1, 65548, 0, 1, 65549, 0, 1, 65550, 0, 1, 65551, 0, 1, 65552, 0, 1, 65553, 0, 1, 65554, 0, 1, 65555, 0, 1, 65556, 0, 1, 65557, 0, 1, 65558, 0, 2, 65559, 0, 2, 65560, 0, 2, 65561, 0, 2, 65562, 0, 2, 65563, 0, 2, 65564, 0, 2, 65565, 0, 2, 65566, 0, 2, 65567, 0, 1, 131072, 0, 2, 131073, 0, 2, 131074, 0, 2, 131075, 0, 1, 131076, 0, 1, 131077, 0, 1, 131078, 0, 0, 131079, 0, 1, 131080, 0, 1, 131081, 0, 2, 131082, 0, 2, 131083, 0, 1, 131084, 0, 1, 131085, 0, 1, 131086, 0, 1, 131087, 0, 1, 131088, 0, 1, 131089, 0, 1, 131090, 0, 1, 131091, 0, 1, 131092, 0, 2, 131093, 0, 2, 131094, 0, 2, 131095, 0, 2, 131096, 0, 2, 131097, 0, 2, 131098, 0, 2, 131099, 0, 2, 131100, 0, 2, 131101, 0, 2, 131102, 0, 2, 131103, 0, 2, 196608, 0, 2, 196609, 0, 1, 196610, 0, 2, 196611, 0, 1, 196612, 0, 1, 196613, 0, 1, 196614, 0, 1, 196615, 0, 2, 196616, 0, 2, 196617, 0, 2, 196618, 0, 2, 196619, 0, 0, 196620, 0, 1, 196621, 0, 1, 196622, 0, 1, 196623, 0, 1, 196624, 0, 1, 196625, 0, 1, 196626, 0, 1, 196627, 0, 1, 196628, 0, 2, 196629, 0, 2, 196630, 0, 2, 196631, 0, 2, 196632, 0, 2, 196633, 0, 2, 196634, 0, 2, 196635, 0, 2, 196636, 0, 2, 196637, 0, 2, 196638, 0, 2, 196639, 0, 1, 262144, 0, 1, 262145, 0, 1, 262146, 0, 1, 262147, 0, 1, 262148, 0, 1, 262149, 0, 0, 262150, 0, 0, 262151, 0, 0, 262152, 0, 1, 262153, 0, 0, 262154, 0, 0, 262155, 0, 1, 262156, 0, 1, 262157, 0, 1, 262158, 0, 1, 262159, 0, 1, 262160, 0, 1, 262161, 0, 1, 262162, 0, 1, 262163, 0, 1, 262164, 0, 1, 262165, 0, 1, 262166, 0, 2, 262167, 0, 2, 262168, 0, 2, 262169, 0, 2, 262170, 0, 2, 262171, 0, 2, 262172, 0, 2, 262173, 0, 2, 262174, 0, 2, 262175, 0, 1, 327680, 0, 1, 327681, 0, 1, 327682, 0, 1, 327683, 0, 1, 327684, 0, 1, 327685, 0, 0, 327686, 0, 0, 327687, 0, 0, 327688, 0, 0, 327689, 0, 1, 327690, 0, 1, 327691, 0, 1, 327692, 0, 1, 327693, 0, 1, 327694, 0, 1, 327695, 0, 1, 327696, 0, 1, 327697, 0, 1, 327698, 0, 1, 327699, 0, 1, 327700, 0, 1, 327701, 0, 1, 327702, 0, 1, 327703, 0, 1, 327704, 0, 3, 327705, 0, 1, 327706, 0, 2, 327707, 0, 2, 327708, 0, 2, 327709, 0, 2, 327710, 0, 2, 327711, 0, 2, 393216, 0, 1, 393217, 0, 1, 393218, 0, 1, 393219, 0, 1, 393220, 0, 1, 393221, 0, 2, 393222, 0, 3, 393223, 0, 1, 393224, 0, 1, 393225, 0, 1, 393226, 0, 1, 393227, 0, 1, 393228, 0, 1, 393229, 0, 1, 393230, 0, 1, 393231, 0, 2, 393232, 0, 2, 393233, 0, 2, 393234, 0, 2, 393235, 0, 1, 393236, 0, 1, 393237, 0, 1, 393238, 0, 1, 393239, 0, 1, 393240, 0, 1, 393241, 0, 2, 393242, 0, 2, 393243, 0, 2, 393244, 0, 2, 393245, 0, 2, 393246, 0, 2, 393247, 0, 2, 458752, 0, 1, 458753, 0, 1, 458754, 0, 1, 458755, 0, 2, 458756, 0, 1, 458757, 0, 2, 458758, 0, 0, 458759, 0, 0, 458760, 0, 1, 458761, 0, 1, 458762, 0, 3, 458763, 0, 2, 458764, 0, 2, 458765, 0, 2, 458766, 0, 2, 458767, 0, 2, 458768, 0, 2, 458769, 0, 1, 458770, 0, 1, 458771, 0, 1, 458772, 0, 1, 458773, 0, 1, 458774, 0, 1, 458775, 0, 1, 458776, 0, 1, 458777, 0, 1, 458778, 0, 2, 458779, 0, 2, 458780, 0, 2, 458781, 0, 2, 458782, 0, 2, 458783, 0, 2, 524288, 0, 1, 524289, 0, 1, 524290, 0, 2, 524291, 0, 2, 524292, 0, 2, 524293, 0, 1, 524294, 0, 1, 524295, 0, 1, 524296, 0, 2, 524297, 0, 2, 524298, 0, 1, 524299, 0, 1, 524300, 0, 1, 524301, 0, 2, 524302, 0, 1, 524303, 0, 1, 524304, 0, 1, 524305, 0, 2, 524306, 0, 2, 524307, 0, 1, 524308, 0, 1, 524309, 0, 1, 524310, 0, 1, 524311, 0, 1, 524312, 0, 1, 524313, 0, 1, 524314, 0, 1, 524315, 0, 1, 524316, 0, 2, 524317, 0, 2, 524318, 0, 2, 524319, 0, 2, 589824, 0, 1, 589825, 0, 1, 589826, 0, 2, 589827, 0, 2, 589828, 0, 1, 589829, 0, 1, 589830, 0, 1, 589831, 0, 1, 589832, 0, 1, 589833, 0, 1, 589834, 0, 2, 589835, 0, 0, 589836, 0, 1, 589837, 0, 2, 589838, 0, 1, 589839, 0, 1, 589840, 0, 1, 589841, 0, 1, 589842, 0, 1, 589843, 0, 1, 589844, 0, 1, 589845, 0, 1, 589846, 0, 1, 589847, 0, 2, 589848, 0, 2, 589849, 0, 2, 589850, 0, 2, 589851, 0, 2, 589852, 0, 2, 589853, 0, 2, 589854, 0, 2, 589855, 0, 1, 655360, 0, 1, 655361, 0, 1, 655362, 0, 1, 655363, 0, 2, 655364, 0, 1, 655365, 0, 1, 655366, 0, 1, 655367, 0, 1, 655368, 0, 1, 655369, 0, 1, 655370, 0, 2, 655371, 0, 1, 655372, 0, 0, 655373, 0, 0, 655374, 0, 0, 655375, 0, 0, 655376, 0, 1, 655377, 0, 1, 655378, 0, 1, 655379, 0, 1, 655380, 0, 1, 655381, 0, 1, 655382, 0, 2, 655383, 0, 2, 655384, 0, 2, 655385, 0, 2, 655386, 0, 2, 655387, 0, 2, 655388, 0, 2, 655389, 0, 1, 655390, 0, 2, 655391, 0, 1, 720896, 0, 1, 720897, 0, 1, 720898, 0, 1, 720899, 0, 2, 720900, 0, 1, 720901, 0, 1, 720902, 0, 1, 720903, 0, 2, 720904, 0, 2, 720905, 0, 2, 720906, 0, 1, 720907, 0, 2, 720908, 0, 2, 720909, 0, 2, 720910, 0, 3, 720911, 0, 1, 720912, 0, 1, 720913, 0, 1, 720914, 0, 1, 720915, 0, 1, 720916, 0, 1, 720917, 0, 1, 720918, 0, 1, 720919, 0, 1, 720920, 0, 1, 720921, 0, 1, 720922, 0, 1, 720923, 0, 1, 720924, 0, 1, 720925, 0, 1, 720926, 0, 2, 720927, 0, 1, 786432, 0, 1, 786433, 0, 1, 786434, 0, 1, 786435, 0, 1, 786436, 0, 1, 786437, 0, 2, 786438, 0, 2, 786439, 0, 2, 786440, 0, 2, 786441, 0, 2, 786442, 0, 2, 786443, 0, 1, 786444, 0, 1, 786445, 0, 1, 786446, 0, 1, 786447, 0, 1, 786448, 0, 1, 786449, 0, 1, 786450, 0, 1, 786451, 0, 1, 786452, 0, 1, 786453, 0, 1, 786454, 0, 1, 786455, 0, 1, 786456, 0, 1, 786457, 0, 1, 786458, 0, 1, 786459, 0, 1, 786460, 0, 1, 786461, 0, 1, 786462, 0, 1, 786463, 0, 1, 851968, 0, 1, 851969, 0, 1, 851970, 0, 1, 851971, 0, 1, 851972, 0, 1, 851973, 0, 1, 851974, 0, 1, 851975, 0, 1, 851976, 0, 1, 851977, 0, 2, 851978, 0, 1, 851979, 0, 2, 851980, 0, 2, 851981, 0, 2, 851982, 0, 2, 851983, 0, 2, 851984, 0, 2, 851985, 0, 1, 851986, 0, 1, 851987, 0, 1, 851988, 0, 1, 851989, 0, 1, 851990, 0, 1, 851991, 0, 1, 851992, 0, 0, 851993, 0, 0, 851994, 0, 1, 851995, 0, 3, 851996, 0, 1, 851997, 0, 0, 851998, 0, 1, 851999, 0, 1, 917504, 0, 1, 917505, 0, 1, 917506, 0, 1, 917507, 0, 1, 917508, 0, 1, 917509, 0, 2, 917510, 0, 1, 917511, 0, 1, 917512, 0, 2, 917513, 0, 2, 917514, 0, 2, 917515, 0, 2, 917516, 0, 2, 917517, 0, 2, 917518, 0, 2, 917519, 0, 2, 917520, 0, 1, 917521, 0, 1, 917522, 0, 1, 917523, 0, 1, 917524, 0, 2, 917525, 0, 1, 917526, 0, 1, 917527, 0, 1, 917528, 0, 0, 917529, 0, 0, 917530, 0, 0, 917531, 0, 0, 917532, 0, 0, 917533, 0, 2, 917534, 0, 0, 917535, 0, 1, 983040, 0, 1, 983041, 0, 1, 983042, 0, 1, 983043, 0, 1, 983044, 0, 2, 983045, 0, 2, 983046, 0, 1, 983047, 0, 1, 983048, 0, 2, 983049, 0, 2, 983050, 0, 2, 983051, 0, 2, 983052, 0, 2, 983053, 0, 2, 983054, 0, 2, 983055, 0, 2, 983056, 0, 2, 983057, 0, 1, 983058, 0, 1, 983059, 0, 1, 983060, 0, 1, 983061, 0, 1, 983062, 0, 1, 983063, 0, 1, 983064, 0, 0, 983065, 0, 2, 983066, 0, 2, 983067, 0, 2, 983068, 0, 2, 983069, 0, 2, 983070, 0, 2, 983071, 0, 2, 1048576, 0, 1, 1048577, 0, 3, 1048578, 0, 1, 1048579, 0, 1, 1048580, 0, 1, 1048581, 0, 1, 1048582, 0, 2, 1048583, 0, 2, 1048584, 0, 1, 1048585, 0, 1, 1048586, 0, 2, 1048587, 0, 2, 1048588, 0, 2, 1048589, 0, 2, 1048590, 0, 2, 1048591, 0, 2, 1048592, 0, 1, 1048593, 0, 2, 1048594, 0, 1, 1048595, 0, 1, 1048596, 0, 1, 1048597, 0, 1, 1048598, 0, 1, 1048599, 0, 2, 1048600, 0, 2, 1048601, 0, 2, 1048602, 0, 2, 1048603, 0, 2, 1048604, 0, 2, 1048605, 0, 2, 1048606, 0, 2, 1048607, 0, 2, 1114112, 0, 1, 1114113, 0, 1, 1114114, 0, 1, 1114115, 0, 2, 1114116, 0, 1, 1114117, 0, 1, 1114118, 0, 2, 1114119, 0, 2, 1114120, 0, 2, 1114121, 0, 1, 1114122, 0, 1, 1114123, 0, 2, 1114124, 0, 2, 1114125, 0, 2, 1114126, 0, 2, 1114127, 0, 2, 1114128, 0, 2, 1114129, 0, 1, 1114130, 0, 1, 1114131, 0, 2, 1114132, 0, 1, 1114133, 0, 1, 1114134, 0, 1, 1114135, 0, 2, 1114136, 0, 2, 1114137, 0, 2, 1114138, 0, 2, 1114139, 0, 2, 1114140, 0, 2, 1114141, 0, 2, 1114142, 0, 2, 1114143, 0, 2, 1179648, 0, 1, 1179649, 0, 1, 1179650, 0, 1, 1179651, 0, 2, 1179652, 0, 2, 1179653, 0, 1, 1179654, 0, 1, 1179655, 0, 1, 1179656, 0, 2, 1179657, 0, 2, 1179658, 0, 2, 1179659, 0, 2, 1179660, 0, 2, 1179661, 0, 1, 1179662, 0, 2, 1179663, 0, 2, 1179664, 0, 1, 1179665, 0, 2, 1179666, 0, 1, 1179667, 0, 2, 1179668, 0, 2, 1179669, 0, 2, 1179670, 0, 2, 1179671, 0, 2, 1179672, 0, 2, 1179673, 0, 2, 1179674, 0, 2, 1179675, 0, 2, 1179676, 0, 2, 1179677, 0, 2, 1179678, 0, 2, 1179679, 0, 2, 1245184, 0, 1, 1245185, 0, 1, 1245186, 0, 1, 1245187, 0, 2, 1245188, 0, 1, 1245189, 0, 1, 1245190, 0, 1, 1245191, 0, 1, 1245192, 0, 1, 1245193, 0, 1, 1245194, 0, 2, 1245195, 0, 2, 1245196, 0, 1, 1245197, 0, 1, 1245198, 0, 2, 1245199, 0, 2, 1245200, 0, 1, 1245201, 0, 2, 1245202, 0, 2, 1245203, 0, 2, 1245204, 0, 2, 1245205, 0, 1, 1245206, 0, 1, 1245207, 0, 1, 1245208, 0, 2, 1245209, 0, 2, 1245210, 0, 2, 1245211, 0, 2, 1245212, 0, 2, 1245213, 0, 2, 1245214, 0, 2, 1245215, 0, 2, 1310720, 0, 1, 1310721, 0, 2, 1310722, 0, 2, 1310723, 0, 2, 1310724, 0, 1, 1310725, 0, 1, 1310726, 0, 1, 1310727, 0, 2, 1310728, 0, 2, 1310729, 0, 2, 1310730, 0, 2, 1310731, 0, 1, 1310732, 0, 2, 1310733, 0, 1, 1310734, 0, 2, 1310735, 0, 2, 1310736, 0, 1, 1310737, 0, 2, 1310738, 0, 2, 1310739, 0, 1, 1310740, 0, 2, 1310741, 0, 1, 1310742, 0, 1, 1310743, 0, 1, 1310744, 0, 1, 1310745, 0, 1, 1310746, 0, 2, 1310747, 0, 2, 1310748, 0, 2, 1310749, 0, 2, 1310750, 0, 2, 1310751, 0, 1, 1376256, 0, 1, 1376257, 0, 2, 1376258, 0, 2, 1376259, 0, 1, 1376260, 0, 1, 1376261, 0, 1, 1376262, 0, 1, 1376263, 0, 1, 1376264, 0, 1, 1376265, 0, 1, 1376266, 0, 1, 1376267, 0, 1, 1376268, 0, 1, 1376269, 0, 1, 1376270, 0, 1, 1376271, 0, 1, 1376272, 0, 1, 1376273, 0, 1, 1376274, 0, 1, 1376275, 0, 1, 1376276, 0, 1, 1376277, 0, 1, 1376278, 0, 1, 1376279, 0, 1, 1376280, 0, 1, 1376281, 0, 3, 1376282, 0, 1, 1376283, 0, 2, 1376284, 0, 2, 1376285, 0, 2, 1376286, 0, 2, 1376287, 0, 1, 1441792, 0, 1, 1441793, 0, 2, 1441794, 0, 2, 1441795, 0, 2, 1441796, 0, 2, 1441797, 0, 2, 1441798, 0, 2, 1441799, 0, 2, 1441800, 0, 2, 1441801, 0, 2, 1441802, 0, 2, 1441803, 0, 2, 1441804, 0, 2, 1441805, 0, 2, 1441806, 0, 2, 1441807, 0, 1, 1441808, 0, 1, 1441809, 0, 1, 1441810, 0, 1, 1441811, 0, 1, 1441812, 0, 1, 1441813, 0, 1, 1441814, 0, 1, 1441815, 0, 1, 1441816, 0, 1, 1441817, 0, 1, 1441818, 0, 1, 1441819, 0, 2, 1441820, 0, 2, 1441821, 0, 2, 1441822, 0, 2, 1441823, 0, 1, 1507328, 0, 1, 1507329, 0, 1, 1507330, 0, 2, 1507331, 0, 2, 1507332, 0, 1, 1507333, 0, 2, 1507334, 0, 2, 1507335, 0, 1, 1507336, 0, 1, 1507337, 0, 1, 1507338, 0, 1, 1507339, 0, 1, 1507340, 0, 1, 1507341, 0, 1, 1507342, 0, 1, 1507343, 0, 1, 1507344, 0, 1, 1507345, 0, 1, 1507346, 0, 1, 1507347, 0, 1, 1507348, 0, 1, 1507349, 0, 1, 1507350, 0, 2, 1507351, 0, 2, 1507352, 0, 1, 1507353, 0, 2, 1507354, 0, 2, 1507355, 0, 2, 1507356, 0, 2, 1507357, 0, 1, 1507358, 0, 1, 1507359, 0, 1, 1572864, 0, 1, 1572865, 0, 1, 1572866, 0, 1, 1572867, 0, 2, 1572868, 0, 1, 1572869, 0, 1, 1572870, 0, 2, 1572871, 0, 2, 1572872, 0, 2, 1572873, 0, 1, 1572874, 0, 1, 1572875, 0, 0, 1572876, 0, 0, 1572877, 0, 3, 1572878, 0, 1, 1572879, 0, 1, 1572880, 0, 1, 1572881, 0, 1, 1572882, 0, 1, 1572883, 0, 2, 1572884, 0, 2, 1572885, 0, 1, 1572886, 0, 1, 1572887, 0, 1, 1572888, 0, 1, 1572889, 0, 1, 1572890, 0, 1, 1572891, 0, 2, 1572892, 0, 1, 1572893, 0, 1, 1572894, 0, 1, 1572895, 0, 1, 1638400, 0, 1, 1638401, 0, 1, 1638402, 0, 1, 1638403, 0, 2, 1638404, 0, 1, 1638405, 0, 1, 1638406, 0, 2, 1638407, 0, 2, 1638408, 0, 2, 1638409, 0, 2, 1638410, 0, 2, 1638411, 0, 2, 1638412, 0, 2, 1638413, 0, 2, 1638414, 0, 2, 1638415, 0, 1, 1638416, 0, 1, 1638417, 0, 2, 1638418, 0, 1, 1638419, 0, 2, 1638420, 0, 1, 1638421, 0, 1, 1638422, 0, 1, 1638423, 0, 1, 1638424, 0, 1, 1638425, 0, 1, 1638426, 0, 1, 1638427, 0, 1, 1638428, 0, 1, 1638429, 0, 1, 1638430, 0, 1, 1638431, 0, 1, 1703936, 0, 2, 1703937, 0, 1, 1703938, 0, 2, 1703939, 0, 1, 1703940, 0, 2, 1703941, 0, 1, 1703942, 0, 1, 1703943, 0, 2, 1703944, 0, 2, 1703945, 0, 2, 1703946, 0, 2, 1703947, 0, 2, 1703948, 0, 1, 1703949, 0, 1, 1703950, 0, 1, 1703951, 0, 1, 1703952, 0, 1, 1703953, 0, 1, 1703954, 0, 1, 1703955, 0, 1, 1703956, 0, 1, 1703957, 0, 2, 1703958, 0, 1, 1703959, 0, 1, 1703960, 0, 1, 1703961, 0, 1, 1703962, 0, 1, 1703963, 0, 1, 1703964, 0, 1, 1703965, 0, 1, 1703966, 0, 1, 1703967, 0, 1, 1769472, 0, 2, 1769473, 0, 2, 1769474, 0, 1, 1769475, 0, 1, 1769476, 0, 1, 1769477, 0, 1, 1769478, 0, 1, 1769479, 0, 1, 1769480, 0, 1, 1769481, 0, 2, 1769482, 0, 2, 1769483, 0, 1, 1769484, 0, 1, 1769485, 0, 1, 1769486, 0, 1, 1769487, 0, 1, 1769488, 0, 2, 1769489, 0, 2, 1769490, 0, 1, 1769491, 0, 1, 1769492, 0, 1, 1769493, 0, 1, 1769494, 0, 1, 1769495, 0, 1, 1769496, 0, 1, 1769497, 0, 2, 1769498, 0, 1, 1769499, 0, 1, 1769500, 0, 1, 1769501, 0, 1, 1769502, 0, 1, 1769503, 0, 1, 1835008, 0, 2, 1835009, 0, 2, 1835010, 0, 1, 1835011, 0, 2, 1835012, 0, 1, 1835013, 0, 1, 1835014, 0, 1, 1835015, 0, 0, 1835016, 0, 0, 1835017, 0, 2, 1835018, 0, 2, 1835019, 0, 2, 1835020, 0, 2, 1835021, 0, 1, 1835022, 0, 1, 1835023, 0, 1, 1835024, 0, 1, 1835025, 0, 2, 1835026, 0, 1, 1835027, 0, 1, 1835028, 0, 1, 1835029, 0, 2, 1835030, 0, 2, 1835031, 0, 1, 1835032, 0, 1, 1835033, 0, 1, 1835034, 0, 1, 1835035, 0, 1, 1835036, 0, 1, 1835037, 0, 1, 1835038, 0, 1, 1835039, 0, 1, 1900544, 0, 2, 1900545, 0, 2, 1900546, 0, 2, 1900547, 0, 2, 1900548, 0, 1, 1900549, 0, 1, 1900550, 0, 1, 1900551, 0, 1, 1900552, 0, 1, 1900553, 0, 0, 1900554, 0, 2, 1900555, 0, 1, 1900556, 0, 2, 1900557, 0, 1, 1900558, 0, 2, 1900559, 0, 1, 1900560, 0, 1, 1900561, 0, 1, 1900562, 0, 1, 1900563, 0, 1, 1900564, 0, 1, 1900565, 0, 1, 1900566, 0, 1, 1900567, 0, 1, 1900568, 0, 1, 1900569, 0, 1, 1900570, 0, 1, 1900571, 0, 1, 1900572, 0, 1, 1900573, 0, 1, 1900574, 0, 1, 1900575, 0, 1, 1966080, 0, 2, 1966081, 0, 2, 1966082, 0, 1, 1966083, 0, 1, 1966084, 0, 2, 1966085, 0, 1, 1966086, 0, 1, 1966087, 0, 1, 1966088, 0, 1, 1966089, 0, 2, 1966090, 0, 1, 1966091, 0, 2, 1966092, 0, 2, 1966093, 0, 2, 1966094, 0, 2, 1966095, 0, 2, 1966096, 0, 2, 1966097, 0, 2, 1966098, 0, 1, 1966099, 0, 1, 1966100, 0, 1, 1966101, 0, 1, 1966102, 0, 1, 1966103, 0, 3, 1966104, 0, 1, 1966105, 0, 2, 1966106, 0, 1, 1966107, 0, 1, 1966108, 0, 1, 1966109, 0, 1, 1966110, 0, 1, 1966111, 0, 1, 2031616, 0, 2, 2031617, 0, 2, 2031618, 0, 2, 2031619, 0, 2, 2031620, 0, 2, 2031621, 0, 2, 2031622, 0, 2, 2031623, 0, 2, 2031624, 0, 2, 2031625, 0, 2, 2031626, 0, 2, 2031627, 0, 2, 2031628, 0, 2, 2031629, 0, 2, 2031630, 0, 2, 2031631, 0, 1, 2031632, 0, 2, 2031633, 0, 1, 2031634, 0, 1, 2031635, 0, 1, 2031636, 0, 1, 2031637, 0, 2, 2031638, 0, 2, 2031639, 0, 2, 2031640, 0, 2, 2031641, 0, 2, 2031642, 0, 2, 2031643, 0, 2, 2031644, 0, 1, 2031645, 0, 2, 2031646, 0, 1, 2031647, 0, 1, 2097152, 0, 2, 2097154, 0, 2, 2097156, 0, 2, 2097158, 0, 2, 2097160, 0, 2, 2097162, 0, 2, 2097164, 0, 2, 2097166, 0, 2, 2097168, 0, 1, 2097170, 0, 1, 2097172, 0, 1, 2097174, 0, 2, 2097176, 0, 2, 2097178, 0, 2, 2097180, 0, 2, 2097182, 0, 2 ) +script = ExtResource( 2 ) +__meta__ = { +"_edit_group_": true, +"_edit_lock_": true +} + +[node name="GroundHighlightingLayer" type="TileMap" parent="Board"] +material = ExtResource( 3 ) +z_index = 1 +tile_set = ExtResource( 1 ) +cell_size = Vector2( 24, 24 ) +cell_half_offset = 1 +cell_y_sort = true +format = 1 +script = ExtResource( 4 ) +__meta__ = { +"_edit_group_": true, +"_edit_lock_": true +} + +[node name="HighlightingController" type="Node" parent="Board/GroundHighlightingLayer"] +script = ExtResource( 5 ) + +[node name="GroundSelectionLayer" type="TileMap" parent="Board"] +material = ExtResource( 6 ) +z_index = 1 +tile_set = ExtResource( 1 ) +cell_size = Vector2( 24, 24 ) +cell_half_offset = 1 +cell_y_sort = true +format = 1 +script = ExtResource( 7 ) +__meta__ = { +"_edit_group_": true, +"_edit_lock_": true +} + +[node name="Characters" type="Node" parent="Board"] + +[node name="Sprite" type="Sprite" parent="Board/Characters"] +position = Vector2( 84, 40 ) +texture = ExtResource( 8 ) + +[node name="Input" type="Node" parent="."] + +[node name="MouseController" type="Node" parent="Input"] +script = ExtResource( 9 ) diff --git a/TradingCompany.csproj b/TradingCompany.csproj new file mode 100644 index 0000000..866d82c --- /dev/null +++ b/TradingCompany.csproj @@ -0,0 +1,97 @@ + + + + Debug + AnyCPU + {75E22CD0-8A64-4D73-B824-56E32C15C39E} + Library + .mono/temp/bin/$(Configuration) + TradingCompany + TradingCompany + v4.5 + .mono/temp/obj + $(BaseIntermediateOutputPath)/$(Configuration) + + + true + portable + false + DEBUG; + prompt + 4 + false + + + portable + true + prompt + 4 + false + + + true + portable + false + DEBUG;TOOLS; + prompt + 4 + false + + + + $(ProjectDir)/.mono/assemblies/GodotSharp.dll + False + + + $(ProjectDir)/.mono/assemblies/GodotSharpEditor.dll + False + + + + packages\System.Collections.Immutable.1.7.0-preview1.19504.10\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll + True + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TradingCompany.sln b/TradingCompany.sln new file mode 100644 index 0000000..1b4f8a1 --- /dev/null +++ b/TradingCompany.sln @@ -0,0 +1,19 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TradingCompany", "TradingCompany.csproj", "{75E22CD0-8A64-4D73-B824-56E32C15C39E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + Tools|Any CPU = Tools|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {75E22CD0-8A64-4D73-B824-56E32C15C39E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {75E22CD0-8A64-4D73-B824-56E32C15C39E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {75E22CD0-8A64-4D73-B824-56E32C15C39E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {75E22CD0-8A64-4D73-B824-56E32C15C39E}.Release|Any CPU.Build.0 = Release|Any CPU + {75E22CD0-8A64-4D73-B824-56E32C15C39E}.Tools|Any CPU.ActiveCfg = Tools|Any CPU + {75E22CD0-8A64-4D73-B824-56E32C15C39E}.Tools|Any CPU.Build.0 = Tools|Any CPU + EndGlobalSection +EndGlobal diff --git a/TradingCompany.sln.DotSettings b/TradingCompany.sln.DotSettings new file mode 100644 index 0000000..9e1f885 --- /dev/null +++ b/TradingCompany.sln.DotSettings @@ -0,0 +1,2 @@ + + True \ No newline at end of file diff --git a/View/.DS_Store b/View/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..19eb3e33cf766e24bec734f0c5a805e5b9f0de4b GIT binary patch literal 6148 zcmeHKI|>3Z5S{S@f{mqRuHX%VXkqOIECd@_MbvsL&*jm4^J$jFP7CD?OkOgXmylQN z?1+diZ~KMFOhhJdLwVTHH`_Pw*&rhdgyW3seS2w+r{>VheHSq9ST@qgS#BM^?a-(I z6`%rCfC^B7Pb-iWb~63+!90%&P=TLUz`hR!ZdeoBK>u`L@D>0#Lf8#+?GNs z1|kB}paO%c* _board.Rows; + public int Columns => _board.Columns; + public Field[][] Fields => _board.Fields; + } +} \ No newline at end of file diff --git a/View/EventDispatcher.cs b/View/EventDispatcher.cs new file mode 100644 index 0000000..f510f0c --- /dev/null +++ b/View/EventDispatcher.cs @@ -0,0 +1,52 @@ +using System; +using System.Collections.Generic; + +namespace TradingCompany.View { + public static class EventDispatcher { + private static readonly Dictionary>> StoreSubscriptions = + new Dictionary>>(); + + private static readonly Dictionary> ViewSubscriptions = + new Dictionary>(); + + private static bool _isDispatching; + + + public static void RegisterAsStore(EventType eventType, + Action handler) { + if (!StoreSubscriptions.ContainsKey(eventType)) { + StoreSubscriptions.Add(eventType, new List>()); + } + + StoreSubscriptions[eventType].Add(handler); + } + + public static void RegisterAsView(EventType eventType, + Action handler) { + if (!ViewSubscriptions.ContainsKey(eventType)) { + ViewSubscriptions.Add(eventType, new List()); + } + + ViewSubscriptions[eventType].Add(handler); + } + + public static void Dispatch(EventType eventType, + object payload) { + if (_isDispatching) { + throw new ApplicationException("Other event is already being executed"); + } + + _isDispatching = true; + + if (StoreSubscriptions.ContainsKey(eventType)) { + StoreSubscriptions[eventType].ForEach(subscription => { subscription.Invoke(payload); }); + } + + if (ViewSubscriptions.ContainsKey(eventType)) { + ViewSubscriptions[eventType].ForEach(subscription => { subscription.Invoke(); }); + } + + _isDispatching = false; + } + } +} \ No newline at end of file diff --git a/View/EventType.cs b/View/EventType.cs new file mode 100644 index 0000000..5a8e5cc --- /dev/null +++ b/View/EventType.cs @@ -0,0 +1,8 @@ +namespace TradingCompany.View { + public enum EventType { + MousePositionChanged, + MousePressed, + TileHighlighted, + TileSelected + } +} \ No newline at end of file diff --git a/View/GameInitializer.cs b/View/GameInitializer.cs new file mode 100644 index 0000000..baac217 --- /dev/null +++ b/View/GameInitializer.cs @@ -0,0 +1,14 @@ +using Godot; +using TradingCompany.PlayerSupport; +using TradingCompany.View.Board; + +namespace TradingCompany.View { + public class GameInitializer : Node { + public override void _Ready() { + var boardInitializer = GetNode("../Ground"); + var board = boardInitializer.CreateBoard(); + Stores.Initialize(board); + ActionPlanner.Initialize(board); + } + } +} \ No newline at end of file diff --git a/View/Highlighting/HighlightingController.cs b/View/Highlighting/HighlightingController.cs new file mode 100644 index 0000000..bb19349 --- /dev/null +++ b/View/Highlighting/HighlightingController.cs @@ -0,0 +1,18 @@ +using Godot; +using TradingCompany.Model.Math; + +namespace TradingCompany.View.Highlighting { + public class HighlightingController : Node { + private TileMap _highlightingTileMap; + + public override void _Ready() { + _highlightingTileMap = GetParent(); + } + + public override void _Process(float delta) { + var fieldPosition = _highlightingTileMap.WorldToMap(Stores.Mouse.MousePosition); + + EventDispatcher.Dispatch(EventType.TileHighlighted, IntVector2.FromVector2(fieldPosition)); + } + } +} \ No newline at end of file diff --git a/View/Highlighting/TilesHighlightingLayer.cs b/View/Highlighting/TilesHighlightingLayer.cs new file mode 100644 index 0000000..8faadde --- /dev/null +++ b/View/Highlighting/TilesHighlightingLayer.cs @@ -0,0 +1,43 @@ +using Godot; +using TradingCompany.Model.Math; + +namespace TradingCompany.View.Highlighting { + public class TilesHighlightingLayer : TileMap { + private TileMap _groundTileMap; + private IntVector2 _selectedFieldPosition; + + private bool _wasFieldSelected; + + + public override void _Ready() { + _groundTileMap = GetNode("../Ground"); + + EventDispatcher.RegisterAsView(EventType.TileHighlighted, UpdateHighlight); + } + + private void UpdateHighlight() { + ClearCell(); + + if (Stores.TilesHighlighting.IsFieldHighlighted) { + _wasFieldSelected = true; + _selectedFieldPosition = Stores.TilesHighlighting.HighlightedFieldPosition; + UpdateCell(); + } + } + + private void ClearCell() { + if (_wasFieldSelected) { + _wasFieldSelected = false; + SetCellv(_selectedFieldPosition.ToVector2(), -1); + } + } + + private void UpdateCell() { + var x = _selectedFieldPosition.x; + var y = _selectedFieldPosition.y; + var newTileIndex = _groundTileMap.GetCell(x, y); + var autoTileCoordinates = _groundTileMap.GetCellAutotileCoord(x, y); + SetCell(x, y, newTileIndex, false, false, false, autoTileCoordinates); + } + } +} \ No newline at end of file diff --git a/View/Highlighting/TilesHighlightingStore.cs b/View/Highlighting/TilesHighlightingStore.cs new file mode 100644 index 0000000..f0db507 --- /dev/null +++ b/View/Highlighting/TilesHighlightingStore.cs @@ -0,0 +1,33 @@ +using System.ComponentModel; +using TradingCompany.Model.Math; + +namespace TradingCompany.View.Highlighting { + public class TilesHighlightingStore { + public TilesHighlightingStore() { + EventDispatcher.RegisterAsStore(EventType.TileHighlighted, TileHighlightedChanged); + } + + private void TileHighlightedChanged(object position) { + var fieldPosition = (IntVector2) position; + + if (IsOverBoard(fieldPosition)) { + IsFieldHighlighted = true; + HighlightedFieldPosition = fieldPosition; + } + else { + IsFieldHighlighted = false; + } + } + + public bool IsFieldHighlighted { get; private set; } + public IntVector2 HighlightedFieldPosition { get; private set; } + + + private bool IsOverBoard(IntVector2 position) { + return position.x >= 0 + && position.x < Stores.Board.Columns + && position.y >= 0 + && position.y < Stores.Board.Rows; + } + } +} \ No newline at end of file diff --git a/View/Input/MouseController.cs b/View/Input/MouseController.cs new file mode 100644 index 0000000..93a2730 --- /dev/null +++ b/View/Input/MouseController.cs @@ -0,0 +1,20 @@ +using Godot; + +namespace TradingCompany.View.Input { + public class MouseController : Node { + private const int ButtonLeft = 1; + + private bool _wasLeftButtonPressed; + + public override void _Process(float delta) { + EventDispatcher.Dispatch(EventType.MousePositionChanged, GetViewport().GetMousePosition()); + + if (!_wasLeftButtonPressed && Godot.Input.IsMouseButtonPressed(ButtonLeft)) { + GD.Print("User clicked " + GetViewport().GetMousePosition()); + EventDispatcher.Dispatch(EventType.MousePressed, null); + } + + _wasLeftButtonPressed = Godot.Input.IsMouseButtonPressed(ButtonLeft); + } + } +} \ No newline at end of file diff --git a/View/Input/MouseStore.cs b/View/Input/MouseStore.cs new file mode 100644 index 0000000..a2d08e5 --- /dev/null +++ b/View/Input/MouseStore.cs @@ -0,0 +1,15 @@ +using Godot; + +namespace TradingCompany.View.Input { + public class MouseStore { + public MouseStore() { + EventDispatcher.RegisterAsStore(EventType.MousePositionChanged, OnMousePositionChanged); + } + + public Vector2 MousePosition { get; private set; } + + private void OnMousePositionChanged(object position) { + MousePosition = (Vector2) position; + } + } +} \ No newline at end of file diff --git a/View/Selection/TilesSelectionLayer.cs b/View/Selection/TilesSelectionLayer.cs new file mode 100644 index 0000000..08c9d54 --- /dev/null +++ b/View/Selection/TilesSelectionLayer.cs @@ -0,0 +1,56 @@ +using Godot; +using TradingCompany.Model.Math; + +namespace TradingCompany.View.Selection { + public class TilesSelectionLayer : TileMap { + private TileMap _groundTileMap; + private IntVector2 _selectedFieldPosition; + + private bool _wasFieldSelected; + + private Tween _tween = new Tween(); + + + public override void _Ready() { + _groundTileMap = GetNode("../Ground"); + + EventDispatcher.RegisterAsView(EventType.MousePressed, UpdateSelection); + + AddChild(_tween); + } + + private void UpdateSelection() { + ClearCell(); + if (Stores.TilesHighlighting.IsFieldHighlighted) { + _wasFieldSelected = true; + _selectedFieldPosition = Stores.TilesHighlighting.HighlightedFieldPosition; + UpdateCell(); + LaunchTween(); + } + } + + private void ClearCell() { + if (_wasFieldSelected) { + _wasFieldSelected = false; + SetCellv(_selectedFieldPosition.ToVector2(), -1); + } + } + + private void UpdateCell() { + var x = _selectedFieldPosition.x; + var y = _selectedFieldPosition.y; + var newTileIndex = _groundTileMap.GetCell(x, y); + var autoTileCoordinates = _groundTileMap.GetCellAutotileCoord(x, y); + SetCell(x, y, newTileIndex, false, false, false, autoTileCoordinates); + } + + private void LaunchTween() { + _tween.InterpolateProperty(this, "Modulate", + new Color(1, 1, 1, 1), + new Color(1, 1, 1, 0), + 1, + Tween.TransitionType.Linear, Tween.EaseType.Out); + _tween.Start(); + } + } +} \ No newline at end of file diff --git a/View/Stores.cs b/View/Stores.cs new file mode 100644 index 0000000..ccd612e --- /dev/null +++ b/View/Stores.cs @@ -0,0 +1,17 @@ +using TradingCompany.View.Board; +using TradingCompany.View.Highlighting; +using TradingCompany.View.Input; + +namespace TradingCompany.View { + public static class Stores { + public static MouseStore Mouse; + public static TilesHighlightingStore TilesHighlighting; + public static BoardStore Board; + + public static void Initialize(Model.Board board) { + Mouse = new MouseStore(); + TilesHighlighting = new TilesHighlightingStore(); + Board = new BoardStore(board); + } + } +} \ No newline at end of file diff --git a/default_env.tres b/default_env.tres new file mode 100644 index 0000000..20207a4 --- /dev/null +++ b/default_env.tres @@ -0,0 +1,7 @@ +[gd_resource type="Environment" load_steps=2 format=2] + +[sub_resource type="ProceduralSky" id=1] + +[resource] +background_mode = 2 +background_sky = SubResource( 1 ) diff --git a/packages.config b/packages.config new file mode 100644 index 0000000..9647627 --- /dev/null +++ b/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/.signature.p7s b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/.signature.p7s new file mode 100755 index 0000000000000000000000000000000000000000..1c8f5354afe8c8e6115e1805870751cf4387fa4f GIT binary patch literal 18704 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 literal 0 HcmV?d00001 diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/LICENSE.TXT b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/LICENSE.TXT new file mode 100755 index 0000000..fa3121d --- /dev/null +++ b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/LICENSE.TXT @@ -0,0 +1,23 @@ +The MIT License (MIT) + +Copyright (c) .NET Foundation and Contributors + +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/System.Collections.Immutable.1.7.0-preview1.19504.10.nupkg b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/System.Collections.Immutable.1.7.0-preview1.19504.10.nupkg new file mode 100755 index 0000000000000000000000000000000000000000..73424d92e985685be35729b8461d441f5af05d88 GIT binary patch literal 481097 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⋘y=Y!s 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 UAgISV!0%N6f?+#A1xeU{0Co!R*#H0l literal 0 HcmV?d00001 diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/THIRD-PARTY-NOTICES.TXT b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/THIRD-PARTY-NOTICES.TXT new file mode 100755 index 0000000..3a23615 --- /dev/null +++ b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/THIRD-PARTY-NOTICES.TXT @@ -0,0 +1,375 @@ +.NET Core uses third-party libraries or other resources that may be +distributed under licenses different than the .NET Core software. + +In the event that we accidentally failed to list a required notice, please +bring it to our attention. Post an issue or email us: + + dotnet@microsoft.com + +The attached notices are provided for information only. + +License notice for ASP.NET +------------------------------- + +Copyright (c) .NET Foundation. All rights reserved. +Licensed under the Apache License, Version 2.0. + +Available at +https://github.com/aspnet/AspNetCore/blob/master/LICENSE.txt + +License notice for Slicing-by-8 +------------------------------- + +http://sourceforge.net/projects/slicing-by-8/ + +Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved + + +This software program is licensed subject to the BSD License, available at +http://www.opensource.org/licenses/bsd-license.html. + + +License notice for Unicode data +------------------------------- + +http://www.unicode.org/copyright.html#License + +Copyright © 1991-2017 Unicode, Inc. All rights reserved. +Distributed under the Terms of Use in http://www.unicode.org/copyright.html. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Unicode data files and any associated documentation +(the "Data Files") or Unicode software and any associated documentation +(the "Software") to deal in the Data Files or Software +without restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, and/or sell copies of +the Data Files or Software, and to permit persons to whom the Data Files +or Software are furnished to do so, provided that either +(a) this copyright and permission notice appear with all copies +of the Data Files or Software, or +(b) this copyright and permission notice appear in associated +Documentation. + +THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT OF THIRD PARTY RIGHTS. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS +NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL +DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THE DATA FILES OR SOFTWARE. + +Except as contained in this notice, the name of a copyright holder +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in these Data Files or Software without prior +written authorization of the copyright holder. + +License notice for Zlib +----------------------- + +https://github.com/madler/zlib +http://zlib.net/zlib_license.html + +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.11, January 15th, 2017 + + Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler + + 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 in the product documentation would be + appreciated but is not required. + 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. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + +*/ + +License notice for Mono +------------------------------- + +http://www.mono-project.com/docs/about-mono/ + +Copyright (c) .NET Foundation Contributors + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the Software), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +License notice for International Organization for Standardization +----------------------------------------------------------------- + +Portions (C) International Organization for Standardization 1986: + Permission to copy in any form is granted for use with + conforming SGML systems and applications as defined in + ISO 8879, provided this notice is included in all copies. + +License notice for Intel +------------------------ + +"Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +License notice for Xamarin and Novell +------------------------------------- + +Copyright (c) 2015 Xamarin, Inc (http://www.xamarin.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +Copyright (c) 2011 Novell, Inc (http://www.novell.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +Third party notice for W3C +-------------------------- + +"W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE +Status: This license takes effect 13 May, 2015. +This work is being provided by the copyright holders under the following license. +License +By obtaining and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions. +Permission to copy, modify, and distribute this work, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the work or portions thereof, including modifications: +The full text of this NOTICE in a location viewable to users of the redistributed or derivative work. +Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, the W3C Software and Document Short Notice should be included. +Notice of any changes or modifications, through a copyright statement on the new code or document such as "This software or document includes material copied from or derived from [title and URI of the W3C document]. Copyright © [YEAR] W3C® (MIT, ERCIM, Keio, Beihang)." +Disclaimers +THIS WORK IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. +COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT. +The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the work without specific, written prior permission. Title to copyright in this work will at all times remain with copyright holders." + +License notice for Bit Twiddling Hacks +-------------------------------------- + +Bit Twiddling Hacks + +By Sean Eron Anderson +seander@cs.stanford.edu + +Individually, the code snippets here are in the public domain (unless otherwise +noted) — feel free to use them however you please. The aggregate collection and +descriptions are © 1997-2005 Sean Eron Anderson. The code and descriptions are +distributed in the hope that they will be useful, but WITHOUT ANY WARRANTY and +without even the implied warranty of merchantability or fitness for a particular +purpose. + +License notice for Brotli +-------------------------------------- + +Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +compress_fragment.c: +Copyright (c) 2011, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +decode_fuzzer.c: +Copyright (c) 2015 The Chromium Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." + +License notice for Json.NET +------------------------------- + +https://github.com/JamesNK/Newtonsoft.Json/blob/master/LICENSE.md + +The MIT License (MIT) + +Copyright (c) 2007 James Newton-King + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +License notice for vectorized base64 encoding / decoding +-------------------------------------------------------- + +Copyright (c) 2005-2007, Nick Galbreath +Copyright (c) 2013-2017, Alfred Klomp +Copyright (c) 2015-2017, Wojciech Mula +Copyright (c) 2016-2017, Matthieu Darbois +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +- Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.0/System.Collections.Immutable.dll b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.0/System.Collections.Immutable.dll new file mode 100755 index 0000000000000000000000000000000000000000..5f1ac196481fe0612bb6aa32e7873b47f3815392 GIT binary patch literal 180088 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 literal 0 HcmV?d00001 diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.0/System.Collections.Immutable.xml b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.0/System.Collections.Immutable.xml new file mode 100755 index 0000000..088230d --- /dev/null +++ b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.0/System.Collections.Immutable.xml @@ -0,0 +1,5141 @@ + + + + System.Collections.Immutable + + + + Represents an immutable collection of key/value pairs. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of keys in the dictionary. + The type of values in the dictionary. + + + Adds an element with the specified key and value to the dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Retrieves an empty dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether the immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Represents a list of elements that cannot be modified. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Makes a copy of the list, and adds the specified object to the end of the copied list. + The object to add to the list. + A new list with the object added. + + + Makes a copy of the list and adds the specified objects to the end of the copied list. + The objects to add to the list. + A new list with the elements added. + + + Creates a list with all the items removed, but with the same sorting and ordering semantics as this list. + An empty list that has the same sorting and ordering semantics as this instance. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the . This value can be null for reference types. + The zero-based starting indexes of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use to locate . + The zero-based index of the first occurrence of within the range of elements in the that starts at and contains number of elements if found; otherwise -1. + + + Inserts the specified element at the specified index in the immutable list. + The zero-based index at which to insert the value. + The object to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The zero-based index at which the new elements should be inserted. + The elements to insert. + A new immutable list that includes the specified elements. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to match . + Returns . + + + Removes the first occurrence of a specified object from this immutable list. + The object to remove from the list. + The equality comparer to use to locate . + A new list with the specified object removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes the specified object from the list. + The objects to remove from the list. + The equality comparer to use to determine if match any objects in the list. + A new immutable list with the specified objects removed, if matched objects in the list. + + + Removes a range of elements from the . + The zero-based starting index of the range of elements to remove. + The number of elements to remove. + A new immutable list with the elements removed. + + + Returns a new list with the first matching element in the list replaced with the specified element. + The element to be replaced. + The element to replace the first occurrence of with + The equality comparer to use for matching . + A new list that contains , even if is the same as . + + does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + A new list that contains the new element, even if the element at the specified location is the same as the new element. + + + Represents an immutable first-in, first-out collection of objects. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Returns a new queue with all the elements removed. + An empty immutable queue. + + + Removes the first element in the immutable queue, and returns the new queue. + The new immutable queue with the first element removed. This value is never null. + The queue is empty. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue with the specified element added. + + + Gets a value that indicates whether this immutable queue is empty. + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Represents a set of elements that can only be modified by creating a new instance of the set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored in the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable set contains a specified element. + The element to locate in the set. + + if the set contains the specified value; otherwise, . + + + Removes the elements in the specified collection from the current immutable set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains only elements that exist in this set and the specified set. + The collection to compare to the current . + A new immutable set that contains elements that exist in both sets. + + + Determines whether the current immutable set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a proper (strict) superset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, false. + + + Determines whether the current immutable set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Determines whether the current immutable set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Determines whether the set contains a specified value. + The value to search for. + The matching value from the set, if found, or equalvalue if there are no matches. + + if a matching value was found; otherwise, . + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Represents an immutable last-in-first-out (LIFO) collection. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets a value that indicates whether this immutable stack is empty. + + if this stack is empty; otherwise,. + + + Returns the element at the top of the immutable stack without removing it. + The element at the top of the stack. + The stack is empty. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never null + The stack is empty. + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + Provides methods for creating an array that is immutable; meaning it cannot be changed once it is created. +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Searches the sorted immutable array for a specified element using the default comparer and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The comparer implementation to use when comparing elements, or null to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . + + is less than the lower bound of . +-or- + is less than zero. + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The comparer to use when comparing elements for equality or to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . +-or- + is , and is of a type that is not compatible with the elements of . + + is less than the lower bound of . +-or- + is less than zero. + + + Creates an empty immutable array. + The type of elements stored in the array. + An empty immutable array. + + + Creates an immutable array that contains the specified object. + The object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified object. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The fourth object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array from the specified array of objects. + The array of objects to populate the array with. + The type of elements stored in the array. + An immutable array that contains the array of items. + + + Creates an immutable array with specified objects from another array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates an immutable array with the specified objects from another immutable array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The initial capacity of the builder. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a new populated with the specified items. + The elements to add to the array. + The type of element stored in the array. + An immutable array that contains the specified items. + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + An argument to be passed to the selector mapping function. + + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + An argument to be passed to the selector mapping function. + + + + + + Creates an immutable array from the specified collection. + The collection of objects to copy to the immutable array. + The type of elements contained in . + An immutable array that contains the specified collection of objects. + + + Creates an immutable array from the current contents of the builder's array. + The builder to create the immutable array from. + The type of elements contained in the immutable array. + An immutable array that contains the current contents of the builder's array. + + + Represents an array that is immutable; meaning it cannot be changed once it is created. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored by the array. + + + Returns a copy of the original array with the specified item added to the end. + The item to be added to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a new immutable array that contains the elements of this array cast to a different type. + The type of array element to return. + An immutable array that contains the elements of this array, cast to a different type. If the cast fails, returns an array whose property returns . + + + Creates a new read-only memory region over this immutable array. + The read-only memory representation of this immutable array. + + + Creates a new read-only span over this immutable array. + The read-only span representation of this immutable array. + + + A writable array accessor that can be converted into an instance without allocating extra memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the array. + The object to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Gets or sets the length of the internal array. When set, the internal array is reallocated to the given capacity if it is not already the specified length. + The length of the internal array. + + + Removes all items from the array. + + + Determines whether the array contains a specific value. + The object to locate in the array. + + if the object is found; otherwise, . + + + Copies the current contents to the specified array. + The array to copy to. + The index to start the copy operation. + + + Gets or sets the number of items in the array. + The number of items in the array. + + + Gets an object that can be used to iterate through the collection. + An object that can be used to iterate through the collection. + + + Determines the index of a specific item in the array. + The item to locate in the array. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The number of elements to search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index for the specified item. + The item to locate in the array. + The index at which to begin the search. + The starting position of the search. + The equality comparer to use in the search + The index of if it's found in the list; otherwise, -1. + + + Inserts an item in the array at the specified index. + The zero-based index at which to insert the item. + The object to insert into the array. + + + Gets or sets the item at the specified index. + The index of the item to get or set. + The item at the specified index. + The specified index is not in the array. + + + Gets a read-only reference to the element at the specified index. + The item index. + The read-only reference to the element at the specified index. + + is greater or equal to the array count. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The 0-based index where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Extracts the internal array as an and replaces it with a zero length array. + When doesn't equal . + + + Removes the specified element. + The item to remove. + + if was found and removed; otherwise, . + + + Removes the item at the specified index from the array. + The zero-based index of the item to remove. + + + Reverses the order of elements in the collection. + + + Sorts the contents of the array. + + + Sorts the contents of the array. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Sorts the elements in the entire array using the specified . + The to use when comparing elements. + + is null. + + + Sorts the contents of the array. + The starting index for the sort. + The number of elements to include in the sort. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Creates a new array with the current contents of this . + A new array with the contents of this . + + + Returns an immutable array that contains the current contents of this . + An immutable array that contains the current contents of this . + + + Initializes a new instance of the struct by casting the underlying array to an array of type . + + Thrown if the cast is illegal. + + + Initializes a new instance of the struct based on the contents of an existing instance, allowing a covariant static cast to efficiently reuse the existing array. + The array to initialize the array with. No copy is made. + + + + Returns an array with all the elements removed. + An array with all of the elements removed. + + + Determines whether the specified item exists in the array. + The item to search for. + + if the specified item was found in the array; otherwise . + + + Copies the contents of this array to the specified array. + The array to copy to. + + + Copies the contents of this array to the specified array starting at the specified destination index. + The array to copy to. + The index in where copying begins. + + + Copies the specified items in this array to the specified array at the specified starting index. + The index of this array where copying begins. + The array to copy to. + The index in where copying begins. + The number of elements to copy from this array. + + + Gets an empty immutable array. + + + An array enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the current item. + The current item. + + + Advances to the next value in the array. + + if another item exists in the array; otherwise, . + + + Indicates whether specified array is equal to this array. + An object to compare with this object. + + if is equal to this array; otherwise, . + + + Determines if this array is equal to the specified object. + The to compare with this array. + + if this array is equal to ; otherwise, . + + + Returns an enumerator that iterates through the contents of the array. + An enumerator. + + + Returns a hash code for this instance. + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + Searches the array for the specified item. + The item to search for. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the item inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Gets a value indicating whether this array was declared but not initialized. + + if the is ; otherwise, . + + + Gets a value indicating whether this is empty or is not initialized. + + if the is or ; otherwise, . + + + Gets a value indicating whether this is empty. + + if the is empty; otherwise, . + + + Gets the element at the specified index in the immutable array. + The zero-based index of the element to get. + The element at the specified index in the immutable array. + + + Gets a read-only reference to the element at the specified in the read-only list. + The zero-based index of the element to get a reference to. + A read-only reference to the element at the specified in the read-only list. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Gets the number of elements in the array. + The number of elements in the array + + + Filters the elements of this array to those assignable to the specified type. + The type to filter the elements of the sequence on. + An that contains elements from the input sequence of type of . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates whether two arrays are not equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are not equal; otherwise, . + + + Checks for inequality between two array. + The object to the left of the operator. + The object to the right of the operator. + + if the two arrays are not equal; otherwise, . + + + Returns an array with the first occurrence of the specified element removed from the array. If no match is found, the current array is returned. + The item to remove. + A new array with the item removed. + + + Returns an array with the first occurrence of the specified element removed from the array. + If no match is found, the current array is returned. + The item to remove. + The equality comparer to use in the search. + A new array with the specified item removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the item at the specified index removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + A new array with the elements removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + A new list with the elements removed. + + + Removes the specified items from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The item to add to the list. + The new array that contains at the specified index. + + + Sorts the elements in the immutable array using the default comparer. + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the immutable array using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the entire using the specified . + The to use when comparing elements. + The sorted list. + + is null. + + + Sorts the specified elements in the immutable array using the specified comparer. + The index of the first element to sort. + The number of elements to include in the sort. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Throws in all cases. + The item to add to the end of the array. + + + Throws in all cases. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Throws in all cases. + The object to remove from the array. + Throws in all cases. + + + Returns an enumerator that iterates through the array. + An enumerator that can be used to iterate through the array. + + + Throws in all cases. + The index of the location to insert the item. + The item to insert. + + + Gets or sets the element at the specified index in the read-only list. + The zero-based index of the element to get. + The element at the specified index in the read-only list. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The index. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets the element at the specified index. + The index. + The element. + Thrown if the property returns true. + + + Copies this array to another array starting at the specified index. + The array to copy this array to. + The index in the destination array to start the copy operation. + + + Gets the size of the array. + Thrown if the property returns true. + + + See the interface. + + + Gets the sync root. + + + Returns an enumerator that iterates through the immutable array. + An enumerator that iterates through the immutable array. + The property returns . + + + Throws in all cases. + The value to add to the array. + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + The value to check for. + Throws in all cases. + + + Gets the value at the specified index. + The value to return the index of. + The value of the element at the specified index. + + + Throws in all cases. + Index that indicates where to insert the item. + The value to insert. + Thrown in all cases. + + + Gets a value indicating whether this instance is fixed size. + + true if this instance is fixed size; otherwise, false. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Gets or sets the at the specified index. + The index. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The value to remove from the array. + Thrown in all cases. + + + Throws in all cases. + The index of the item to remove. + Thrown in all cases. + + + Returns a copy of the original array with the specified item added to the end. + The value to add to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the end of the array. + A new array with the elements added to the end. + + + Returns an array with all the elements removed. + An array with all the elements removed. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the specified value inserted. + + + Inserts the specified values at the specified index + The index at which to insert the value. + The elements to insert. + A new array with the specified values inserted. + + + Returns an array with the first occurrence of the specified element removed from the array; if no match is found, the current array is returned. + The value to remove from the array. + The equality comparer to use in the search. + A new array with the value removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the specified item removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The value to add to the list. + The new array that contains at the specified index. + + + Determines whether the current collection element precedes, occurs in the same position as, or follows another element in the sort order. + The element to compare with the current instance. + The object used to compare members of the current array with the corresponding members of other array. + An integer that indicates whether the current element precedes, is in the same position or follows the other element. + The arrays are not the same length. + + + Determines whether this array is structurally equal to the specified array. + The array to compare with the current instance. + An object that determines whether the current instance and other are structurally equal. + + if the two arrays are structurally equal; otherwise, . + + + Returns a hash code for the current instance. + An object that computes the hash code of the current object. + The hash code for the current instance. + + + Creates a mutable array that has the same contents as this array and can be efficiently mutated across multiple operations using standard mutable interfaces. + The new builder with the same contents as this array. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Determines whether the specified immutable dictionary contains the specified key/value pair. + The immutable dictionary to search. + The key to locate in the immutable dictionary. + The value to locate on the specified key, if the key is found. + The type of the keys in the immutable dictionary. + The type of the values in the immutable dictionary. + + if this map contains the specified key/value pair; otherwise, . + + + Creates an empty immutable dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates a new immutable dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary that contains the specified items. + The items used to populate the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The comparer implementation to use to compare values for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The type of the key. + The type of the value. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The type of the key. + The type of the value. + The value for the key, or if no matching key was found. + + + Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Constructs an immutable dictionary based on some transformation of a sequence. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The key comparer to use for the dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable dictionary from the current contents of the builder's dictionary. + The builder to create the immutable dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Represents an immutable, unordered collection of keys and values. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the keys in the dictionary. + The type of the values in the dictionary. + + + Adds an element with the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the immutable dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a hash map that mutates with little or no memory allocations and that can produce or build on immutable hash map instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + + is null. + An element with the same key already exists in the dictionary. + The dictionary is read-only. + + + Adds the specified item to the immutable dictionary. + The object to add to the dictionary. + The dictionary is read-only. + + + Adds a sequence of values to this collection. + The items to add to this collection. + + + Removes all items from the immutable dictionary. + The dictionary is read-only. + + + Determines whether the immutable dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element that has the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + is null. + + + Determines whether the immutable dictionary contains an element that has the specified value. + The value to locate in the immutable dictionary. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements contained in the immutable dictionary. + The number of elements contained in the immutable dictionary. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the collection. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the element with the specified key. + The element to get or set. + The element that has the specified key. + + is . + The property is being retrieved, and is not found. + The property is being set, and the is read-only. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a collection that contains the keys of the immutable dictionary. + A collection that contains the keys of the object that implements the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the dictionary. + + is null. + The dictionary is read-only. + + + Removes the first occurrence of a specific object from the immutable dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns false if is not found in the dictionary. + The dictionary is read-only. + + + Removes any entries with keys that match those found in the specified sequence from the immutable dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array of type , starting at the specified array index. + The one-dimensional array of type that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable dictionary based on the contents of this instance. + An immutable dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Returns the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, returns the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the immutable dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets or sets the value comparer. + The value comparer. + + + Gets a collection that contains the values of the immutable dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified key. + The key to locate. + + if the immutable dictionary contains an element with the specified key; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable dictionary + + + Enumerates the contents of the immutable dictionary without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element in the dictionary at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the dictionary. + The dictionary was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the dictionary. + The dictionary was modified after the enumerator was created. + + + Gets the current element. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The type of the key. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable dictionary. + The key comparer. + + + Gets the keys in the immutable dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the immutable dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Gets the values in the immutable dictionary. + The values in the immutable dictionary. + + + Gets an instance of the immutable dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable hash set. + The type of items to be stored in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the specified array of items. + An array that contains the items to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates an empty immutable hash set that uses the specified equality comparer. + The object to use for comparing objects in the set for equality. + The type of items in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the items in the specified collection and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + An array that contains the items to prepopulate the hash set with. + The type of items stored in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates a new immutable hash set builder. + The type of items stored by the collection. + The immutable hash set builder. + + + Creates a new immutable hash set builder. + The object to use for comparing objects in the set for equality. + The type of items stored by the collection. + The new immutable hash set builder. + + + Creates a new immutable hash set prefilled with the specified items. + The items to add to the hash set. + The type of items stored by the collection. + The new immutable hash set that contains the specified items. + + + Creates a new immutable hash set that contains the specified items and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The items add to the collection before immutability is applied. + The type of items stored in the collection. + The new immutable hash set. + + + Enumerates a sequence and produces an immutable hash set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type. + The sequence to enumerate. + The object to use for comparing objects in the set for equality. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence and uses the specified equality comparer. + + + Creates an immutable hash set from the current contents of the builder's set. + The builder to create the immutable hash set from. + The type of the elements in the hash set. + An immutable hash set that contains the current contents in the builder's set. + + + Represents an immutable, unordered hash set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the hash set. + + + Adds the specified element to the hash set. + The element to add to the set. + A hash set that contains the added value and any values previously held by the object. + + + Represents a hash set that mutates with little or no memory allocations and that can produce or build on immutable hash set instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the immutable hash set. + The item to add. + + if the item did not already belong to the collection; otherwise, . + + + Removes all items from the immutable hash set. + The hash set is read-only. + + + Determines whether the immutable hash set contains a specific value. + The object to locate in the hash set. + + if is found in the hash set ; otherwise, . + + + Gets the number of elements contained in the immutable hash set. + The number of elements contained in the immutable hash set. + + + Removes all elements in the specified collection from the current hash set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the immutable hash set. + An enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets or sets the key comparer. + The key comparer. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of a specific object from the immutable hash set. + The object to remove from the set. + + if was successfully removed from the set ; otherwise, . This method also returns if is not found in the original set. + The set is read-only. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an item to the hash set. + The object to add to the set. + The set is read-only. + + + Copies the elements of the hash set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the hash set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current set. + + + Retrieves an empty immutable hash set that has the same sorting and ordering semantics as this instance. + An empty hash set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable hash set contains the specified element. + The object to locate in the immutable hash set. + + if is found in the ; otherwise, . + + + Gets the number of elements in the immutable hash set. + The number of elements in the hash set. + + + Gets an immutable hash set for this type that uses the default . + + + Enumerates the contents of the immutable hash set without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable hash set. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the hash set. + The hash set was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the hash set. + The hash set was modified after the enumerator was created. + + + Gets the current element. + + + Removes the elements in the specified collection from the current immutable hash set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Gets a value that indicates whether the current immutable hash set is empty. + + if this instance is empty; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Gets the object that is used to obtain hash codes for the keys and to check the equality of values in the immutable hash set. + The comparer used to obtain hash codes for the keys and check equality. + + + Determines whether the current immutable hash set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable hash set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable hash set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable hash set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Adds an item to the set. + The object to add to the set. + The set is read-only. + + + Removes all items from this set. + The set is read-only. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + + if the element is successfully removed; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that iterates through the collection. + + + Adds an element to the current set and returns a value that indicates whether the element was successfully added. + The element to add to the collection. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current collection. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or in the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a set. + An enumerator that can be used to iterate through the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting or ordering semantics as this instance. + + + Removes the elements in the specified collection from the current set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates an immutable hash set that has the same contents as this set and can be efficiently mutated across multiple operations by using standard mutable interfaces. + A set with the same contents as this set that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Creates a new immutable hash set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable hash set with the items added; or the original set if all the items were already in the set. + + + Gets an instance of the immutable hash set that uses the specified equality comparer for its search methods. + The equality comparer to use. + An instance of this immutable hash set that uses the given comparer. + + + Contains interlocked exchange mechanisms for immutable collections. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The value to use if no previous value exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The function that receives the key and returns a new value to add to the dictionary when no value previously exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Atomically enqueues an element to the end of a queue. + The variable or field to atomically update. + The value to enqueue. + The type of items contained in the collection + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified key is not in the dictionary. + The key for the value to get or add. + The value to add to the dictionary the key is not found. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. This delegate will not be invoked more than once. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. + The argument to pass to the value factory. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The type of the argument supplied to the value factory. + The value at the specified key or if the key was not present. + + + Compares two immutable arrays for equality and, if they are equal, replaces one of the arrays. + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The type of element stored by the array. + The original value in . + + + Sets an array to the specified array and returns a reference to the original array, as an atomic operation. + The array to set to the specified value. + The value to which the parameter is set. + The type of element stored by the array. + The original value of . + + + Sets an array to the specified array if the array has not been initialized. + The array to set to the specified value. + The value to which the parameter is set, if it's not initialized. + The type of element stored by the array. + + if the array was assigned the specified value; otherwise, . + + + Pushes a new element onto the stack. + The stack to update. + The value to push on the stack. + The type of items in the stack. + + + Adds the specified key and value to the dictionary if the key is not in the dictionary. + The dictionary to update with the specified key and value. + The key to add, if is not already defined in the dictionary. + The value to add. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key is not in the dictionary; otherwise, . + + + Atomically removes and returns the specified element at the head of the queue, if the queue is not empty. + The variable or field to atomically update. + Set to the value from the head of the queue, if the queue not empty. + The type of items in the queue. + + if the queue is not empty and the head element is removed; otherwise, . + + + Removes an element from the top of the stack, if there is an element to remove. + The stack to update. + Receives the value removed from the stack, if the stack is not empty. + The type of items in the stack. + + if an element is removed from the stack; otherwise, . + + + Removes the element with the specified key, if the key exists. + The dictionary to update. + The key to remove. + Receives the value of the removed item, if the dictionary is not empty. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key was found and removed; otherwise, . + + + Sets the specified key to the specified value if the specified key already is set to a specific value. + The dictionary to update. + The key to update. + The new value to set. + The current value for in order for the update to succeed. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if and are present in the dictionary and comparison was updated to ; otherwise, . + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The type of data. + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The argument to pass to . + The type of data. + The type of argument passed to the . + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable list. + The type of items to be stored in the . + An empty immutable list. + + + Creates a new immutable list that contains the specified item. + The item to prepopulate the list with. + The type of items in the . + A new that contains the specified item. + + + Creates a new immutable list that contains the specified array of items. + An array that contains the items to prepopulate the list with. + The type of items in the . + A new immutable list that contains the specified items. + + + Creates a new immutable list builder. + The type of items stored by the collection. + The immutable collection builder. + + + Creates a new immutable list that contains the specified items. + The items to add to the list. + The type of items in the . + An immutable list that contains the specified items. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Removes the specified value from this list. + The list to search. + The value to remove. + The type of items in the list. + A new immutable list with the element removed, or this list if the element is not in this list. + + + Removes the specified values from this list. + The list to search. + The items to remove if matches are found in this list. + The type of items in the list. + A new immutable list with the elements removed. + + + Replaces the first equal element in the list with the specified element. + The list to search. + The element to replace. + The element to replace the old element with. + The type of items in the list. + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + Enumerates a sequence and produces an immutable list of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable list that contains the items in the specified sequence. + + + Creates an immutable list from the current contents of the builder's collection. + The builder to create the immutable list from. + The type of the elements in the list. + An immutable list that contains the current contents in the builder's collection. + + + Represents an immutable list, which is a strongly typed list of objects that can be accessed by index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Adds the specified object to the end of the immutable list. + The object to add. + A new immutable list with the object added. + + + Adds the elements of the specified collection to the end of the immutable list. + The collection whose elements will be added to the end of the list. + A new immutable list with the elements added. + + + Searches the entire sorted list for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be for reference types. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + The default comparer cannot find a comparer implementation of the for type T. + + + Searches the entire sorted list for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements or null to use the default comparer. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + comparer is , and the default comparer cannot find an comparer implementation for type T. + + + Searches a range of elements in the sorted list for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements, or to use the default comparer. + The zero-based index of item in the sorted list, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + index is less than 0 or is less than 0. + index and do not denote a valid range in the list. + + is , and the default comparer cannot find an comparer implementation for type T. + + + Represents a list that mutates with little or no memory allocations and that can produce or build on immutable list instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an item to the immutable list. + The item to add to the list. + + + Adds a series of elements to the end of this list. + The elements to add to the end of the list. + + + Searches the entire for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + The default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the entire for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the specified range of the for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is less than 0. +-or- + is less than 0. + + and do not denote a valid range in the . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Removes all items from the immutable list. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if item is found in the list; otherwise, . + + + Creates a new immutable list from the list represented by this builder by using the converter function. + The converter function. + The type of the output of the delegate converter function. + A new immutable list from the list represented by this builder. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + The number of elements to copy. + + + Gets the number of elements in this immutable list. + The number of elements in this list. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Performs the specified action on each element of the list. + The delegate to perform on each element of the list. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the first occurrence of within the range of elements in the immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Inserts an item to the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the immutable list. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which the new elements should be inserted. + The collection whose elements should be inserted into the immutable list. The collection itself cannot be , but it can contain elements that are null, if type T is a reference type. + + + Gets or sets the value for a given index in the list. + The index of the item to get or set. + The value at the specified index. + + + Gets a read-only reference to the value for a given into the list. + The index of the desired element. + A read-only reference to the value at the specified . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the last occurrence of within the entire immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that extends from the first element to , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that contains number of elements and ends at , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + + if item was successfully removed from the list; otherwise, . This method also returns if item is not found in the list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The number of elements removed from the immutable list. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove from the list. + + + Reverses the order of the elements in the entire immutable list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + + + Sorts the elements in the entire immutable list by using the default comparer. + + + Sorts the elements in the entire immutable list by using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + + + Sorts the elements in the entire immutable list by using the specified comparison object. + The object to use when comparing elements. + + is . + + + Sorts the elements in a range of elements in the immutable list by using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Copies the elements of the list to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Adds an item to the list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + + + + Removes all items from the list. + + + + Determines whether the list contains a specific value. + The object to locate in the list. + + if the is found in the list; otherwise, . + + + + Determines the index of a specific item in the list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item to the list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + + + Removes the first occurrence of a specific object from the list. + The object to remove from the list. + + + + Creates an immutable list based on the contents of this instance. + An immutable list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Removes all elements from the immutable list. + An empty list that retains the same sort or unordered semantics that this instance has. + + + Determines whether this immutable list contains the specified value. + The value to locate. + + if the list contains the specified value; otherwise, . + + + Converts the elements in the current immutable list to another type, and returns a list containing the converted elements. + A delegate that converts each element from one type to another type. + The type of the elements of the target array. + A list of the target type containing the converted elements from the current . + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Copies a range of elements from the immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + The number of elements to copy. + + + Gets the number of elements contained in the list. + The number of elements in the list. + + + Gets an empty set with the default sort comparer. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances enumeration to the next element of the immutable list. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the list. + + + Sets the enumerator to its initial position, which is before the first element in the immutable list. + + + The current element. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list that contains all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Performs the specified action on each element of the immutable list. + The delegate to perform on each element of the immutable list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the immutable list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be null for reference types. + The zero-based index of the first occurrence of within the entire immutable list, if found; otherwise, ?1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the list that starts at the specified index and contains the specified number of elements. + The object to locate in the list The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the first occurrence of item within the range of elements in the list that starts at index and contains count number of elements, if found; otherwise, -1. + + + Inserts the specified object into the immutable list at the specified index. + The zero-based index at which to insert the object. + The object to insert. + The new immutable list after the object is inserted. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which to insert the elements. + The collection whose elements should be inserted. + The new immutable list after the elements are inserted. + + + Gets a value that indicates whether this list is empty. + + if the list is empty; otherwise, . + + + Gets the element at the specified index of the list. + The index of the element to retrieve. + The element at the specified index. + In a get operation, is negative or not less than . + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + is negative or not less than . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the list that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the last occurrence of item within the range of elements in the list that contains count number of elements and ends at index, if found; otherwise, -1. + + + Removes the first occurrence of the specified object from this immutable list. + The object to remove. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes the first occurrence of the object that matches the specified value from this immutable list. + The value of the element to remove from the list. + The equality comparer to use in the search. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The new list with the elements removed. + + + Removes the element at the specified index. + The zero-based index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list. + The collection whose elements should be removed if matches are found in this list. + A new list with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new list with the elements removed. + + + Removes a range of elements, starting from the specified index and containing the specified number of elements, from this immutable list. + The starting index to begin removal. + The number of elements to remove. + A new list with the elements removed. + + + Replaces the specified element in the immutable list with a new element. + The element to replace. + The element to replace with. + The new list with the replaced element, even if it is equal to the old element. + + does not exist in the immutable list. + + + Replaces the specified element in the immutable list with a new element. + The element to replace in the list. + The element to replace with. + The comparer to use to check for equality. + A new list with the object replaced, or this list if the specified object is not in this list. + + + Reverses the order of the elements in the entire immutable list. + The reversed list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + The reversed list. + + + Replaces an element at a given position in the immutable list with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list with the replaced element, even if it is equal to the old element at that position. + + + Sorts the elements in the entire immutable list using the default comparer. + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The delegate to use when comparing elements. + The sorted list. + + is . + + + Sorts a range of elements in the immutable list using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Adds the specified item to the immutable list. + The item to add. + + + + Removes all items from the immutable list. + + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove. + + if was successfully removed from the list; otherwise, . This method also returns if is not found in the original list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Inserts an object in the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert. + + + + Gets or sets the value at the specified index. + + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the value at the specified index. + The zero-based index of the item to remove. + + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified array index. + The one-dimensional array that is the destination of the elements copied from immutable list. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Adds an item to the immutable list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the list. + Always thrown. + + + Removes all items from the immutable list. + Always thrown. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if the object is found in the list; otherwise, . + + + + Determines the index of a specific item in the immutable list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item into the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + Always thrown. + + + Gets a value indicating whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The value at the specified index. + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + Always thrown. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove. + Always thrown. + + + Adds the specified value to this immutable list. + The value to add. + A new list with the element added. + + + Adds the specified values to this immutable list. + The values to add. + A new list with the elements added. + + + Retrieves an empty list that has the same sorting and ordering semantics as this instance. + An empty list that has the same sorting and ordering semantics as this instance. + + + Inserts the specified element at the specified index in the immutable list. + The index at which to insert the value. + The element to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The index at which to insert the elements. + The elements to insert. + A new immutable list that includes the specified elements. + + + Removes the element with the specified value from the list. + The value of the element to remove from the list. + The comparer to use to compare elements for equality. + A new with the specified element removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list that match the items specified. + The range of items to remove from the list, if found. + The equality comparer to use to compare elements. + An immutable list with the items removed. + + or is . + + + Removes the specified number of elements at the specified location from this list. + The starting index of the range of elements to remove. + The number of elements to remove. + A new list with the elements removed. + + + Replaces an element in the list with the specified element. + The element to replace. + The element to replace the old element with. + The equality comparer to use in the search. + The new list. + Thrown when the old value does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list. + + + Creates a list that has the same contents as this list and can be efficiently mutated across multiple operations using standard mutable interfaces. + The created list with the same contents as this list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable queue. + The type of items to be stored in the immutable queue. + An empty immutable queue. + + + Creates a new immutable queue that contains the specified item. + The item to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified item. + + + Creates a new immutable queue that contains the specified array of items. + An array that contains the items to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified items. + + + Creates a new immutable queue that contains the specified items. + The items to add to the queue before immutability is applied. + The type of elements in the queue. + An immutable queue that contains the specified items. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + The queue to remove the item from. + When this method returns, contains the item from the beginning of the queue. + The type of elements in the immutable queue. + The new queue with the item removed. + The stack is empty. + + + Represents an immutable queue. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Removes all objects from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + The queue is empty. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + When this method returns, contains the element from the beginning of the queue. + The new immutable queue with the beginning element removed. + The queue is empty. + + + Gets an empty immutable queue. + An empty immutable queue. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Enumerates the contents of an immutable queue without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable queue. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the queue. + + + Returns an enumerator that iterates through the immutable queue. + An enumerator that can be used to iterate through the queue. + + + Gets a value that indicates whether this immutable queue is empty. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Gets a read-only reference to the element at the front of the queue. + The queue is empty. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates a new immutable sorted dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key comparer. + The comparer implementation to use to evaluate keys for equality and sorting. + The items to add to the sorted dictionary. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + The new immutable sorted dictionary that contains the specified items and uses the specified key comparer. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key and value comparers. + The comparer implementation to use to compare keys for equality and sorting. + The comparer implementation to use to compare values for equality and sorting. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items and uses the specified comparers. + + + Creates an immutable sorted dictionary that contains the specified items and uses the default comparer. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable sorted dictionary from the current contents of the builder's dictionary. + The builder to create the immutable sorted dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Represents an immutable sorted dictionary. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the key contained in the dictionary. + The type of the value contained in the dictionary. + + + Adds an element with the specified key and value to the immutable sorted dictionary. + The key of the entry to add. + The value of entry to add. + A new immutable sorted dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specific key/value pairs to the immutable sorted dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a sorted dictionary that mutates with little or no memory allocations and that can produce or build on immutable sorted dictionary instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable sorted dictionary. + The key of the element to add. + The value of the element to add. + + + Adds the specified item to the immutable sorted dictionary. + The object to add to the dictionary. + + + Adds a sequence of values to the immutable sorted dictionary. + The items to add to the dictionary. + + + Removes all items from the immutable sorted dictionary. + + + Determines whether the immutable sorted dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate in the dictionary. The value can be for reference types. + + if the immutable sorted dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements in this immutable sorted dictionary. + The number of elements in this dictionary. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the value for a specified key in the immutable sorted dictionary. + The key to retrieve the value for. + The value associated with the given key. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a strongly typed, read-only collection of elements. + A strongly typed, read-only collection of elements. + + + Removes the element with the specified key from the immutable sorted dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the original dictionary. + + + Removes the first occurrence of a specific object from the immutable sorted dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns if is not found in the dictionary. + + + Removes any entries with keys that match those found in the specified sequence from the immutable sorted dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable sorted dictionary based on the contents of this instance. + An immutable sorted dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + + Gets or sets the value comparer. + The value comparer. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets a collection that contains the values of the immutable sorted dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable sorted dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable sorted dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether this immutable sorted map contains the specified key. + The key to locate. + + if the immutable dictionary contains the specified key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable sorted dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable sorted dictionary. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable sorted dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted dictionary. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted dictionary. + + + The current element. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable sorted dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The key to retrieve the value for. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable sorted dictionary. + The key comparer for the dictionary. + + + Gets the keys in the immutable sorted dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified value from the immutable sorted dictionary. + The value of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified value cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable sorted dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable sorted dictionary, possibly overwriting an existing value for the given key. + The key of the entry to add. + The key value to set. + A new immutable sorted dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable sorted dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + An immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable sorted dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. + + if the dictionary contains an element with the specified key; otherwise, . + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets the values in the immutable sorted dictionary. + The values in the dictionary. + + + Gets an instance of the immutable sorted dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable sorted dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted set. + The type of items to be stored in the immutable set. + An empty immutable sorted set. + + + Creates a new immutable sorted set that contains the specified item. + The item to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Creates an empty immutable sorted set that uses the specified comparer. + The implementation to use when comparing items in the set. + The type of items in the immutable set. + An empty immutable set. + + + Creates a new immutable sorted set that contains the specified item and uses the specified comparer. + The implementation to use when comparing items in the set. + The item to prepopulate the set with. + The type of items stored in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items and uses the specified comparer. + The implementation to use when comparing items in the set. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Returns a collection that can be used to build an immutable sorted set. + The type of items stored by the collection. + The immutable collection builder. + + + Returns a collection that can be used to build an immutable sorted set. + The comparer used to compare items in the set for equality. + The type of items stored by the collection. + The immutable collection. + + + Creates a new immutable collection that contains the specified items. + The comparer to use to compare elements in this set. + The items to add to the set before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Creates a new immutable collection that contains the specified items. + The items to add to the set with before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Enumerates a sequence and produces an immutable sorted set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer. + The sequence to enumerate. + The comparer to use for initializing and adding members to the sorted set. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Creates an immutable sorted set from the current contents of the builder's set. + The builder to create the immutable sorted set from. + The type of the elements in the immutable sorted set. + An immutable sorted set that contains the current contents in the builder's set. + + + Represents an immutable sorted set implementation. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the set. + + + Adds the specified value to this immutable sorted set. + The value to add. + A new set with the element added, or this set if the element is already in this set. + + + Represents a sorted set that enables changes with little or no memory allocations, and efficiently manipulates or builds immutable sorted sets. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set + + + Removes all elements from this set. + + + Determines whether the set contains the specified object. + The object to locate in the set. + + if is found in the set; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in this set. + + + Removes the specified set of items from the current set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the set. + A enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection is compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the set at the given index. + The 0-based index of the element in the set to return. + The element at the given position. + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + + Gets or sets the object that is used to determine equality for the values in the immutable sorted set. + The comparer that is used to determine equality for the values in the set. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of the specified object from the set. + The object to remove from the set. + + if was removed from the set; if was not found in the set. + + + Returns an enumerator that iterates over the immutable sorted set in reverse order. + An enumerator that iterates over the set in reverse order. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread-safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Creates an immutable sorted set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current state. + + + Removes all elements from the immutable sorted set. + An empty set with the elements removed. + + + Determines whether this immutable sorted set contains the specified value. + The value to check for. + + if the set contains the specified value; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in the immutable sorted set. + + + Gets an empty immutable sorted set. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Advances the enumerator to the next element of the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted set. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + The current element. + + + Removes a specified set of items from this immutable sorted set. + The items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the immutable sorted set. + An enumerator that can be used to iterate through the set. + + + Gets the position within this immutable sorted set that the specified value appears in. + The value whose position is being sought. + The index of the specified in the sorted set, if is found. If is not found and is less than one or more elements in this set, this method returns a negative number that is the bitwise complement of the index of the first element that is larger than value. If is not found and is greater than any of the elements in the set, this method returns a negative number that is the bitwise complement of the index of the last element plus 1. + + + Creates an immutable sorted set that contains elements that exist both in this set and in the specified set. + The set to intersect with this one. + A new immutable sorted set that contains any elements that exist in both sets. + + + Gets a value that indicates whether this immutable sorted set is empty. + + if this set is empty; otherwise, . + + + Determines whether the current immutable sorted set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a proper superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current immutable sorted set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the immutable sorted set at the given index. + The index of the element to retrieve from the sorted set. + The element at the given index. + + + Gets a read-only reference of the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference of the element at the given position. + + + Gets the comparer used to sort keys in the immutable sorted set. + The comparer used to sort keys. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current immutable sorted set and a specified collection share common elements. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the specified value from this immutable sorted set. + The element to remove. + A new immutable sorted set with the element removed, or this set if the element was not found in the set. + + + Returns an that iterates over this immutable sorted set in reverse order. + An enumerator that iterates over the immutable sorted set in reverse order. + + + Determines whether the current immutable sorted set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable sorted set that contains elements that exist either in this set or in a given sequence, but not both. + The other sequence of items. + The new immutable sorted set. + + + Adds the specified value to the collection. + The value to add. + + + Removes all the items from the collection. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the collection. + The object to remove from the collection. + + if was successfully removed from the collection; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Inserts an item in the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + + + See the interface. + + + + Removes the item at the specified index. + The zero-based index of the item to remove. + + + Adds an element to the current set and returns a value to indicate if the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove from the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection + The collection to compare to the current set. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Adds an item to the set. + The object to add to the set. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + The set is read-only or has a fixed size. + + + Removes all items from the set. + Thrown in all cases. + + + Determines whether the set contains a specific value. + The object to locate in the set. + + if the object is found in the set; otherwise, . + + + Determines the index of a specific item in the set. + The object to locate in the set. + The index of if found in the list; otherwise, -1. + + + Inserts an item into the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + The set is read-only or has a fixed size. + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The . + + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + The set is read-only or has a fixed size. + + + Removes the item at the specified index of the set. + The zero-based index of the item to remove. + The set is read-only or has a fixed size. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Removes the elements in the specified collection from the current immutable set. + The items to remove from this set. + The new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates a collection that has the same contents as this immutable sorted set that can be efficiently manipulated by using standard mutable interfaces. + The sorted set builder. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Adds a given set of items to this immutable sorted set. + The items to add. + The new set with the items added; or the original set if all the items were already in the set. + + + Returns the immutable sorted set that has the specified key comparer. + The comparer to check for. + The immutable sorted set that has the specified key comparer. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable stack. + The type of items to be stored in the immutable stack. + An empty immutable stack. + + + Creates a new immutable stack that contains the specified item. + The item to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable collection that contains the specified item. + + + Creates a new immutable stack that contains the specified array of items. + An array that contains the items to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable stack that contains the specified items. + + + Creates a new immutable stack that contains the specified items. + The items to add to the stack before it's immutable. + The type of items in the stack. + An immutable stack that contains the specified items. + + + Removes the specified item from an immutable stack. + The stack to modify. + The item to remove from the stack. + The type of items contained in the stack. + A stack; never . + The stack is empty. + + + Represents an immutable stack. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element on the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets an empty immutable stack. + An empty immutable stack. + + + Enumerates the contents of an immutable stack without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable stack. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the stack. + + + Returns an enumerator that iterates through the immutable stack. + An enumerator that can be used to iterate through the stack. + + + Gets a value that indicates whether this instance of the immutable stack is empty. + + if this instance is empty; otherwise, . + + + Returns the object at the top of the stack without removing it. + The object at the top of the stack. + The stack is empty. + + + Gets a read-only reference to the element on the top of the stack. + A read-only reference to the element on the top of the stack. + Thrown when the stack is empty. + + + Removes the element at the top of the immutable stack and returns the stack after the removal. + A stack; never . + The stack is empty. + + + Removes the specified element from the immutable stack and returns the stack after the removal. + The value to remove from the stack. + A stack; never . + + + Inserts an object at the top of the immutable stack and returns the new stack. + The object to push onto the stack. + The new stack. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable stack. + The empty immutable stack. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never . + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + LINQ extension method overrides that offer greater efficiency for than the standard LINQ methods +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + A function to be invoked on each element, in a cumulative way. + The type of element contained by the collection. + The final value after the cumulative function has been applied to all elements. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + The type of the accumulated value. + The type of element contained by the collection. + The final accumulator value. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + + The type of the accumulated value. + The type of result returned by the result selector. + The type of element contained by the collection. + The final accumulator value. + + + Gets a value indicating whether all elements in this array match a given condition. + The array to check for matches. + The predicate. + The type of element contained by the collection. + + if every element of the source sequence passes the test in the specified predicate; otherwise, . + + + Gets a value indicating whether the array contains any elements. + The array to check for elements. + The type of element contained by the collection. + + if the array contains an elements; otherwise, . + + + Gets a value indicating whether the array contains any elements that match a specified condition. + The array to check for elements. + The delegate that defines the condition to match to an element. + The type of element contained by the collection. + + if an element matches the specified condition; otherwise, . + + + Returns a value indicating whether this collection contains any elements. + The builder to check for matches. + The type of elements in the array. + + if the array builder contains any elements; otherwise, . + + + Returns the element at a specified index in the array. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index. + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index, or the default value if the index is not found. + + + Returns the first element in an array. + The array to get an item from. + The type of element contained by the collection. + The first item in the array. + If the array is empty. + + + Returns the first element in a sequence that satisfies a specified condition. + The array to get an item from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list if it meets the condition specified by . + If the array is empty. + + + Returns the first element in the collection. + The builder to retrieve an item from. + The type of items in the array. + The first item in the list. + If the array is empty. + + + Returns the first element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve elements from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the last element of the array. + The array to retrieve items from. + The type of element contained by the array. + The last element in the array. + Thrown if the collection is empty. + + + Returns the last element of a sequence that satisfies a specified condition. + The array to retrieve elements from. + The delegate that defines the conditions of the element to retrieve. + The type of element contained by the collection. + The last element of the array that satisfies the condition. + Thrown if the collection is empty. + + + Returns the last element in the collection. + The builder to retrieve elements from. + The type of item in the builder. + The last element in the builder. + Thrown if the collection is empty. + + + Returns the last element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve an element from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Projects each element of a sequence into a new form. + The immutable array to select items from. + A transform function to apply to each element. + The type of element contained by the collection. + The type of the result element. + An whose elements are the result of invoking the transform function on each element of source. + + + Projects each element of a sequence to an , flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. + The immutable array. + A transform function to apply to each element of the input sequence. + A transform function to apply to each element of the intermediate sequence. + The type of the elements of . + The type of the intermediate elements collected by . + The type of the elements of the resulting sequence. + An whose elements are the result of invoking the one-to-many transform function on each element of and then mapping each of those sequence elements and their corresponding source element to a result element. + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence. + The array to retrieve the element from. + The type of element contained by the collection. + The element in the sequence. + + + Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists. + + + The type of element contained by the collection. + Returns . + + + Returns the only element of the array, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence. + The array. + The type of element contained by the collection. + The element in the array, or the default value if the array is empty. + + contains more than one element. + + + Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. + The array to get the element from. + The condition the element must satisfy. + The type of element contained by the collection. + The element if it satisfies the specified condition; otherwise the default element. + More than one element satisfies the condition in . + + + Copies the contents of this array to a mutable array. + + The type of element contained by the collection. + The newly instantiated array. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Filters a sequence of values based on a predicate. + The array to filter. + The condition to use for filtering the array content. + The type of element contained by the collection. + Returns that contains elements that meet the condition. + + + diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.3/System.Collections.Immutable.dll b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard1.3/System.Collections.Immutable.dll new file mode 100755 index 0000000000000000000000000000000000000000..fdf8ee60c203ca1569191105fb4f55552fd0d93b GIT binary patch literal 181624 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

|nSOJXOO6SqYw!Q0W?|x|mlh*%tU#HTYp$ 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 + + + System.Collections.Immutable + + + +

Represents an immutable collection of key/value pairs. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of keys in the dictionary. + The type of values in the dictionary. + + + Adds an element with the specified key and value to the dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Retrieves an empty dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether the immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Represents a list of elements that cannot be modified. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Makes a copy of the list, and adds the specified object to the end of the copied list. + The object to add to the list. + A new list with the object added. + + + Makes a copy of the list and adds the specified objects to the end of the copied list. + The objects to add to the list. + A new list with the elements added. + + + Creates a list with all the items removed, but with the same sorting and ordering semantics as this list. + An empty list that has the same sorting and ordering semantics as this instance. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the . This value can be null for reference types. + The zero-based starting indexes of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use to locate . + The zero-based index of the first occurrence of within the range of elements in the that starts at and contains number of elements if found; otherwise -1. + + + Inserts the specified element at the specified index in the immutable list. + The zero-based index at which to insert the value. + The object to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The zero-based index at which the new elements should be inserted. + The elements to insert. + A new immutable list that includes the specified elements. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to match . + Returns . + + + Removes the first occurrence of a specified object from this immutable list. + The object to remove from the list. + The equality comparer to use to locate . + A new list with the specified object removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes the specified object from the list. + The objects to remove from the list. + The equality comparer to use to determine if match any objects in the list. + A new immutable list with the specified objects removed, if matched objects in the list. + + + Removes a range of elements from the . + The zero-based starting index of the range of elements to remove. + The number of elements to remove. + A new immutable list with the elements removed. + + + Returns a new list with the first matching element in the list replaced with the specified element. + The element to be replaced. + The element to replace the first occurrence of with + The equality comparer to use for matching . + A new list that contains , even if is the same as . + + does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + A new list that contains the new element, even if the element at the specified location is the same as the new element. + + + Represents an immutable first-in, first-out collection of objects. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Returns a new queue with all the elements removed. + An empty immutable queue. + + + Removes the first element in the immutable queue, and returns the new queue. + The new immutable queue with the first element removed. This value is never null. + The queue is empty. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue with the specified element added. + + + Gets a value that indicates whether this immutable queue is empty. + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Represents a set of elements that can only be modified by creating a new instance of the set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored in the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable set contains a specified element. + The element to locate in the set. + + if the set contains the specified value; otherwise, . + + + Removes the elements in the specified collection from the current immutable set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains only elements that exist in this set and the specified set. + The collection to compare to the current . + A new immutable set that contains elements that exist in both sets. + + + Determines whether the current immutable set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a proper (strict) superset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, false. + + + Determines whether the current immutable set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Determines whether the current immutable set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Determines whether the set contains a specified value. + The value to search for. + The matching value from the set, if found, or equalvalue if there are no matches. + + if a matching value was found; otherwise, . + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Represents an immutable last-in-first-out (LIFO) collection. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets a value that indicates whether this immutable stack is empty. + + if this stack is empty; otherwise,. + + + Returns the element at the top of the immutable stack without removing it. + The element at the top of the stack. + The stack is empty. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never null + The stack is empty. + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + Provides methods for creating an array that is immutable; meaning it cannot be changed once it is created. +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Searches the sorted immutable array for a specified element using the default comparer and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The comparer implementation to use when comparing elements, or null to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . + + is less than the lower bound of . +-or- + is less than zero. + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The comparer to use when comparing elements for equality or to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . +-or- + is , and is of a type that is not compatible with the elements of . + + is less than the lower bound of . +-or- + is less than zero. + + + Creates an empty immutable array. + The type of elements stored in the array. + An empty immutable array. + + + Creates an immutable array that contains the specified object. + The object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified object. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The fourth object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array from the specified array of objects. + The array of objects to populate the array with. + The type of elements stored in the array. + An immutable array that contains the array of items. + + + Creates an immutable array with specified objects from another array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates an immutable array with the specified objects from another immutable array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The initial capacity of the builder. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a new populated with the specified items. + The elements to add to the array. + The type of element stored in the array. + An immutable array that contains the specified items. + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + An argument to be passed to the selector mapping function. + + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + An argument to be passed to the selector mapping function. + + + + + + Creates an immutable array from the specified collection. + The collection of objects to copy to the immutable array. + The type of elements contained in . + An immutable array that contains the specified collection of objects. + + + Creates an immutable array from the current contents of the builder's array. + The builder to create the immutable array from. + The type of elements contained in the immutable array. + An immutable array that contains the current contents of the builder's array. + + + Represents an array that is immutable; meaning it cannot be changed once it is created. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored by the array. + + + Returns a copy of the original array with the specified item added to the end. + The item to be added to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a new immutable array that contains the elements of this array cast to a different type. + The type of array element to return. + An immutable array that contains the elements of this array, cast to a different type. If the cast fails, returns an array whose property returns . + + + Creates a new read-only memory region over this immutable array. + The read-only memory representation of this immutable array. + + + Creates a new read-only span over this immutable array. + The read-only span representation of this immutable array. + + + A writable array accessor that can be converted into an instance without allocating extra memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the array. + The object to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Gets or sets the length of the internal array. When set, the internal array is reallocated to the given capacity if it is not already the specified length. + The length of the internal array. + + + Removes all items from the array. + + + Determines whether the array contains a specific value. + The object to locate in the array. + + if the object is found; otherwise, . + + + Copies the current contents to the specified array. + The array to copy to. + The index to start the copy operation. + + + Gets or sets the number of items in the array. + The number of items in the array. + + + Gets an object that can be used to iterate through the collection. + An object that can be used to iterate through the collection. + + + Determines the index of a specific item in the array. + The item to locate in the array. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The number of elements to search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index for the specified item. + The item to locate in the array. + The index at which to begin the search. + The starting position of the search. + The equality comparer to use in the search + The index of if it's found in the list; otherwise, -1. + + + Inserts an item in the array at the specified index. + The zero-based index at which to insert the item. + The object to insert into the array. + + + Gets or sets the item at the specified index. + The index of the item to get or set. + The item at the specified index. + The specified index is not in the array. + + + Gets a read-only reference to the element at the specified index. + The item index. + The read-only reference to the element at the specified index. + + is greater or equal to the array count. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The 0-based index where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Extracts the internal array as an and replaces it with a zero length array. + When doesn't equal . + + + Removes the specified element. + The item to remove. + + if was found and removed; otherwise, . + + + Removes the item at the specified index from the array. + The zero-based index of the item to remove. + + + Reverses the order of elements in the collection. + + + Sorts the contents of the array. + + + Sorts the contents of the array. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Sorts the elements in the entire array using the specified . + The to use when comparing elements. + + is null. + + + Sorts the contents of the array. + The starting index for the sort. + The number of elements to include in the sort. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Creates a new array with the current contents of this . + A new array with the contents of this . + + + Returns an immutable array that contains the current contents of this . + An immutable array that contains the current contents of this . + + + Initializes a new instance of the struct by casting the underlying array to an array of type . + + Thrown if the cast is illegal. + + + Initializes a new instance of the struct based on the contents of an existing instance, allowing a covariant static cast to efficiently reuse the existing array. + The array to initialize the array with. No copy is made. + + + + Returns an array with all the elements removed. + An array with all of the elements removed. + + + Determines whether the specified item exists in the array. + The item to search for. + + if the specified item was found in the array; otherwise . + + + Copies the contents of this array to the specified array. + The array to copy to. + + + Copies the contents of this array to the specified array starting at the specified destination index. + The array to copy to. + The index in where copying begins. + + + Copies the specified items in this array to the specified array at the specified starting index. + The index of this array where copying begins. + The array to copy to. + The index in where copying begins. + The number of elements to copy from this array. + + + Gets an empty immutable array. + + + An array enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the current item. + The current item. + + + Advances to the next value in the array. + + if another item exists in the array; otherwise, . + + + Indicates whether specified array is equal to this array. + An object to compare with this object. + + if is equal to this array; otherwise, . + + + Determines if this array is equal to the specified object. + The to compare with this array. + + if this array is equal to ; otherwise, . + + + Returns an enumerator that iterates through the contents of the array. + An enumerator. + + + Returns a hash code for this instance. + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + Searches the array for the specified item. + The item to search for. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the item inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Gets a value indicating whether this array was declared but not initialized. + + if the is ; otherwise, . + + + Gets a value indicating whether this is empty or is not initialized. + + if the is or ; otherwise, . + + + Gets a value indicating whether this is empty. + + if the is empty; otherwise, . + + + Gets the element at the specified index in the immutable array. + The zero-based index of the element to get. + The element at the specified index in the immutable array. + + + Gets a read-only reference to the element at the specified in the read-only list. + The zero-based index of the element to get a reference to. + A read-only reference to the element at the specified in the read-only list. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Gets the number of elements in the array. + The number of elements in the array + + + Filters the elements of this array to those assignable to the specified type. + The type to filter the elements of the sequence on. + An that contains elements from the input sequence of type of . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates whether two arrays are not equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are not equal; otherwise, . + + + Checks for inequality between two array. + The object to the left of the operator. + The object to the right of the operator. + + if the two arrays are not equal; otherwise, . + + + Returns an array with the first occurrence of the specified element removed from the array. If no match is found, the current array is returned. + The item to remove. + A new array with the item removed. + + + Returns an array with the first occurrence of the specified element removed from the array. + If no match is found, the current array is returned. + The item to remove. + The equality comparer to use in the search. + A new array with the specified item removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the item at the specified index removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + A new array with the elements removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + A new list with the elements removed. + + + Removes the specified items from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The item to add to the list. + The new array that contains at the specified index. + + + Sorts the elements in the immutable array using the default comparer. + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the immutable array using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the entire using the specified . + The to use when comparing elements. + The sorted list. + + is null. + + + Sorts the specified elements in the immutable array using the specified comparer. + The index of the first element to sort. + The number of elements to include in the sort. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Throws in all cases. + The item to add to the end of the array. + + + Throws in all cases. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Throws in all cases. + The object to remove from the array. + Throws in all cases. + + + Returns an enumerator that iterates through the array. + An enumerator that can be used to iterate through the array. + + + Throws in all cases. + The index of the location to insert the item. + The item to insert. + + + Gets or sets the element at the specified index in the read-only list. + The zero-based index of the element to get. + The element at the specified index in the read-only list. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The index. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets the element at the specified index. + The index. + The element. + Thrown if the property returns true. + + + Copies this array to another array starting at the specified index. + The array to copy this array to. + The index in the destination array to start the copy operation. + + + Gets the size of the array. + Thrown if the property returns true. + + + See the interface. + + + Gets the sync root. + + + Returns an enumerator that iterates through the immutable array. + An enumerator that iterates through the immutable array. + The property returns . + + + Throws in all cases. + The value to add to the array. + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + The value to check for. + Throws in all cases. + + + Gets the value at the specified index. + The value to return the index of. + The value of the element at the specified index. + + + Throws in all cases. + Index that indicates where to insert the item. + The value to insert. + Thrown in all cases. + + + Gets a value indicating whether this instance is fixed size. + + true if this instance is fixed size; otherwise, false. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Gets or sets the at the specified index. + The index. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The value to remove from the array. + Thrown in all cases. + + + Throws in all cases. + The index of the item to remove. + Thrown in all cases. + + + Returns a copy of the original array with the specified item added to the end. + The value to add to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the end of the array. + A new array with the elements added to the end. + + + Returns an array with all the elements removed. + An array with all the elements removed. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the specified value inserted. + + + Inserts the specified values at the specified index + The index at which to insert the value. + The elements to insert. + A new array with the specified values inserted. + + + Returns an array with the first occurrence of the specified element removed from the array; if no match is found, the current array is returned. + The value to remove from the array. + The equality comparer to use in the search. + A new array with the value removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the specified item removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The value to add to the list. + The new array that contains at the specified index. + + + Determines whether the current collection element precedes, occurs in the same position as, or follows another element in the sort order. + The element to compare with the current instance. + The object used to compare members of the current array with the corresponding members of other array. + An integer that indicates whether the current element precedes, is in the same position or follows the other element. + The arrays are not the same length. + + + Determines whether this array is structurally equal to the specified array. + The array to compare with the current instance. + An object that determines whether the current instance and other are structurally equal. + + if the two arrays are structurally equal; otherwise, . + + + Returns a hash code for the current instance. + An object that computes the hash code of the current object. + The hash code for the current instance. + + + Creates a mutable array that has the same contents as this array and can be efficiently mutated across multiple operations using standard mutable interfaces. + The new builder with the same contents as this array. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Determines whether the specified immutable dictionary contains the specified key/value pair. + The immutable dictionary to search. + The key to locate in the immutable dictionary. + The value to locate on the specified key, if the key is found. + The type of the keys in the immutable dictionary. + The type of the values in the immutable dictionary. + + if this map contains the specified key/value pair; otherwise, . + + + Creates an empty immutable dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates a new immutable dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary that contains the specified items. + The items used to populate the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The comparer implementation to use to compare values for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The type of the key. + The type of the value. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The type of the key. + The type of the value. + The value for the key, or if no matching key was found. + + + Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Constructs an immutable dictionary based on some transformation of a sequence. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The key comparer to use for the dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable dictionary from the current contents of the builder's dictionary. + The builder to create the immutable dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Represents an immutable, unordered collection of keys and values. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the keys in the dictionary. + The type of the values in the dictionary. + + + Adds an element with the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the immutable dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a hash map that mutates with little or no memory allocations and that can produce or build on immutable hash map instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + + is null. + An element with the same key already exists in the dictionary. + The dictionary is read-only. + + + Adds the specified item to the immutable dictionary. + The object to add to the dictionary. + The dictionary is read-only. + + + Adds a sequence of values to this collection. + The items to add to this collection. + + + Removes all items from the immutable dictionary. + The dictionary is read-only. + + + Determines whether the immutable dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element that has the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + is null. + + + Determines whether the immutable dictionary contains an element that has the specified value. + The value to locate in the immutable dictionary. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements contained in the immutable dictionary. + The number of elements contained in the immutable dictionary. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the collection. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the element with the specified key. + The element to get or set. + The element that has the specified key. + + is . + The property is being retrieved, and is not found. + The property is being set, and the is read-only. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a collection that contains the keys of the immutable dictionary. + A collection that contains the keys of the object that implements the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the dictionary. + + is null. + The dictionary is read-only. + + + Removes the first occurrence of a specific object from the immutable dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns false if is not found in the dictionary. + The dictionary is read-only. + + + Removes any entries with keys that match those found in the specified sequence from the immutable dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array of type , starting at the specified array index. + The one-dimensional array of type that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable dictionary based on the contents of this instance. + An immutable dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Returns the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, returns the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the immutable dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets or sets the value comparer. + The value comparer. + + + Gets a collection that contains the values of the immutable dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified key. + The key to locate. + + if the immutable dictionary contains an element with the specified key; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable dictionary + + + Enumerates the contents of the immutable dictionary without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element in the dictionary at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the dictionary. + The dictionary was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the dictionary. + The dictionary was modified after the enumerator was created. + + + Gets the current element. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The type of the key. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable dictionary. + The key comparer. + + + Gets the keys in the immutable dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the immutable dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Gets the values in the immutable dictionary. + The values in the immutable dictionary. + + + Gets an instance of the immutable dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable hash set. + The type of items to be stored in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the specified array of items. + An array that contains the items to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates an empty immutable hash set that uses the specified equality comparer. + The object to use for comparing objects in the set for equality. + The type of items in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the items in the specified collection and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + An array that contains the items to prepopulate the hash set with. + The type of items stored in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates a new immutable hash set builder. + The type of items stored by the collection. + The immutable hash set builder. + + + Creates a new immutable hash set builder. + The object to use for comparing objects in the set for equality. + The type of items stored by the collection. + The new immutable hash set builder. + + + Creates a new immutable hash set prefilled with the specified items. + The items to add to the hash set. + The type of items stored by the collection. + The new immutable hash set that contains the specified items. + + + Creates a new immutable hash set that contains the specified items and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The items add to the collection before immutability is applied. + The type of items stored in the collection. + The new immutable hash set. + + + Enumerates a sequence and produces an immutable hash set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type. + The sequence to enumerate. + The object to use for comparing objects in the set for equality. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence and uses the specified equality comparer. + + + Creates an immutable hash set from the current contents of the builder's set. + The builder to create the immutable hash set from. + The type of the elements in the hash set. + An immutable hash set that contains the current contents in the builder's set. + + + Represents an immutable, unordered hash set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the hash set. + + + Adds the specified element to the hash set. + The element to add to the set. + A hash set that contains the added value and any values previously held by the object. + + + Represents a hash set that mutates with little or no memory allocations and that can produce or build on immutable hash set instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the immutable hash set. + The item to add. + + if the item did not already belong to the collection; otherwise, . + + + Removes all items from the immutable hash set. + The hash set is read-only. + + + Determines whether the immutable hash set contains a specific value. + The object to locate in the hash set. + + if is found in the hash set ; otherwise, . + + + Gets the number of elements contained in the immutable hash set. + The number of elements contained in the immutable hash set. + + + Removes all elements in the specified collection from the current hash set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the immutable hash set. + An enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets or sets the key comparer. + The key comparer. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of a specific object from the immutable hash set. + The object to remove from the set. + + if was successfully removed from the set ; otherwise, . This method also returns if is not found in the original set. + The set is read-only. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an item to the hash set. + The object to add to the set. + The set is read-only. + + + Copies the elements of the hash set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the hash set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current set. + + + Retrieves an empty immutable hash set that has the same sorting and ordering semantics as this instance. + An empty hash set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable hash set contains the specified element. + The object to locate in the immutable hash set. + + if is found in the ; otherwise, . + + + Gets the number of elements in the immutable hash set. + The number of elements in the hash set. + + + Gets an immutable hash set for this type that uses the default . + + + Enumerates the contents of the immutable hash set without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable hash set. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the hash set. + The hash set was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the hash set. + The hash set was modified after the enumerator was created. + + + Gets the current element. + + + Removes the elements in the specified collection from the current immutable hash set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Gets a value that indicates whether the current immutable hash set is empty. + + if this instance is empty; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Gets the object that is used to obtain hash codes for the keys and to check the equality of values in the immutable hash set. + The comparer used to obtain hash codes for the keys and check equality. + + + Determines whether the current immutable hash set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable hash set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable hash set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable hash set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Adds an item to the set. + The object to add to the set. + The set is read-only. + + + Removes all items from this set. + The set is read-only. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + + if the element is successfully removed; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that iterates through the collection. + + + Adds an element to the current set and returns a value that indicates whether the element was successfully added. + The element to add to the collection. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current collection. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or in the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a set. + An enumerator that can be used to iterate through the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting or ordering semantics as this instance. + + + Removes the elements in the specified collection from the current set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates an immutable hash set that has the same contents as this set and can be efficiently mutated across multiple operations by using standard mutable interfaces. + A set with the same contents as this set that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Creates a new immutable hash set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable hash set with the items added; or the original set if all the items were already in the set. + + + Gets an instance of the immutable hash set that uses the specified equality comparer for its search methods. + The equality comparer to use. + An instance of this immutable hash set that uses the given comparer. + + + Contains interlocked exchange mechanisms for immutable collections. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The value to use if no previous value exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The function that receives the key and returns a new value to add to the dictionary when no value previously exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Atomically enqueues an element to the end of a queue. + The variable or field to atomically update. + The value to enqueue. + The type of items contained in the collection + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified key is not in the dictionary. + The key for the value to get or add. + The value to add to the dictionary the key is not found. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. This delegate will not be invoked more than once. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. + The argument to pass to the value factory. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The type of the argument supplied to the value factory. + The value at the specified key or if the key was not present. + + + Compares two immutable arrays for equality and, if they are equal, replaces one of the arrays. + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The type of element stored by the array. + The original value in . + + + Sets an array to the specified array and returns a reference to the original array, as an atomic operation. + The array to set to the specified value. + The value to which the parameter is set. + The type of element stored by the array. + The original value of . + + + Sets an array to the specified array if the array has not been initialized. + The array to set to the specified value. + The value to which the parameter is set, if it's not initialized. + The type of element stored by the array. + + if the array was assigned the specified value; otherwise, . + + + Pushes a new element onto the stack. + The stack to update. + The value to push on the stack. + The type of items in the stack. + + + Adds the specified key and value to the dictionary if the key is not in the dictionary. + The dictionary to update with the specified key and value. + The key to add, if is not already defined in the dictionary. + The value to add. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key is not in the dictionary; otherwise, . + + + Atomically removes and returns the specified element at the head of the queue, if the queue is not empty. + The variable or field to atomically update. + Set to the value from the head of the queue, if the queue not empty. + The type of items in the queue. + + if the queue is not empty and the head element is removed; otherwise, . + + + Removes an element from the top of the stack, if there is an element to remove. + The stack to update. + Receives the value removed from the stack, if the stack is not empty. + The type of items in the stack. + + if an element is removed from the stack; otherwise, . + + + Removes the element with the specified key, if the key exists. + The dictionary to update. + The key to remove. + Receives the value of the removed item, if the dictionary is not empty. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key was found and removed; otherwise, . + + + Sets the specified key to the specified value if the specified key already is set to a specific value. + The dictionary to update. + The key to update. + The new value to set. + The current value for in order for the update to succeed. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if and are present in the dictionary and comparison was updated to ; otherwise, . + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The type of data. + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The argument to pass to . + The type of data. + The type of argument passed to the . + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable list. + The type of items to be stored in the . + An empty immutable list. + + + Creates a new immutable list that contains the specified item. + The item to prepopulate the list with. + The type of items in the . + A new that contains the specified item. + + + Creates a new immutable list that contains the specified array of items. + An array that contains the items to prepopulate the list with. + The type of items in the . + A new immutable list that contains the specified items. + + + Creates a new immutable list builder. + The type of items stored by the collection. + The immutable collection builder. + + + Creates a new immutable list that contains the specified items. + The items to add to the list. + The type of items in the . + An immutable list that contains the specified items. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Removes the specified value from this list. + The list to search. + The value to remove. + The type of items in the list. + A new immutable list with the element removed, or this list if the element is not in this list. + + + Removes the specified values from this list. + The list to search. + The items to remove if matches are found in this list. + The type of items in the list. + A new immutable list with the elements removed. + + + Replaces the first equal element in the list with the specified element. + The list to search. + The element to replace. + The element to replace the old element with. + The type of items in the list. + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + Enumerates a sequence and produces an immutable list of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable list that contains the items in the specified sequence. + + + Creates an immutable list from the current contents of the builder's collection. + The builder to create the immutable list from. + The type of the elements in the list. + An immutable list that contains the current contents in the builder's collection. + + + Represents an immutable list, which is a strongly typed list of objects that can be accessed by index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Adds the specified object to the end of the immutable list. + The object to add. + A new immutable list with the object added. + + + Adds the elements of the specified collection to the end of the immutable list. + The collection whose elements will be added to the end of the list. + A new immutable list with the elements added. + + + Searches the entire sorted list for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be for reference types. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + The default comparer cannot find a comparer implementation of the for type T. + + + Searches the entire sorted list for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements or null to use the default comparer. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + comparer is , and the default comparer cannot find an comparer implementation for type T. + + + Searches a range of elements in the sorted list for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements, or to use the default comparer. + The zero-based index of item in the sorted list, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + index is less than 0 or is less than 0. + index and do not denote a valid range in the list. + + is , and the default comparer cannot find an comparer implementation for type T. + + + Represents a list that mutates with little or no memory allocations and that can produce or build on immutable list instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an item to the immutable list. + The item to add to the list. + + + Adds a series of elements to the end of this list. + The elements to add to the end of the list. + + + Searches the entire for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + The default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the entire for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the specified range of the for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is less than 0. +-or- + is less than 0. + + and do not denote a valid range in the . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Removes all items from the immutable list. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if item is found in the list; otherwise, . + + + Creates a new immutable list from the list represented by this builder by using the converter function. + The converter function. + The type of the output of the delegate converter function. + A new immutable list from the list represented by this builder. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + The number of elements to copy. + + + Gets the number of elements in this immutable list. + The number of elements in this list. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Performs the specified action on each element of the list. + The delegate to perform on each element of the list. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the first occurrence of within the range of elements in the immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Inserts an item to the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the immutable list. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which the new elements should be inserted. + The collection whose elements should be inserted into the immutable list. The collection itself cannot be , but it can contain elements that are null, if type T is a reference type. + + + Gets or sets the value for a given index in the list. + The index of the item to get or set. + The value at the specified index. + + + Gets a read-only reference to the value for a given into the list. + The index of the desired element. + A read-only reference to the value at the specified . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the last occurrence of within the entire immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that extends from the first element to , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that contains number of elements and ends at , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + + if item was successfully removed from the list; otherwise, . This method also returns if item is not found in the list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The number of elements removed from the immutable list. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove from the list. + + + Reverses the order of the elements in the entire immutable list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + + + Sorts the elements in the entire immutable list by using the default comparer. + + + Sorts the elements in the entire immutable list by using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + + + Sorts the elements in the entire immutable list by using the specified comparison object. + The object to use when comparing elements. + + is . + + + Sorts the elements in a range of elements in the immutable list by using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Copies the elements of the list to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Adds an item to the list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + + + + Removes all items from the list. + + + + Determines whether the list contains a specific value. + The object to locate in the list. + + if the is found in the list; otherwise, . + + + + Determines the index of a specific item in the list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item to the list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + + + Removes the first occurrence of a specific object from the list. + The object to remove from the list. + + + + Creates an immutable list based on the contents of this instance. + An immutable list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Removes all elements from the immutable list. + An empty list that retains the same sort or unordered semantics that this instance has. + + + Determines whether this immutable list contains the specified value. + The value to locate. + + if the list contains the specified value; otherwise, . + + + Converts the elements in the current immutable list to another type, and returns a list containing the converted elements. + A delegate that converts each element from one type to another type. + The type of the elements of the target array. + A list of the target type containing the converted elements from the current . + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Copies a range of elements from the immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + The number of elements to copy. + + + Gets the number of elements contained in the list. + The number of elements in the list. + + + Gets an empty set with the default sort comparer. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances enumeration to the next element of the immutable list. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the list. + + + Sets the enumerator to its initial position, which is before the first element in the immutable list. + + + The current element. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list that contains all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Performs the specified action on each element of the immutable list. + The delegate to perform on each element of the immutable list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the immutable list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be null for reference types. + The zero-based index of the first occurrence of within the entire immutable list, if found; otherwise, ?1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the list that starts at the specified index and contains the specified number of elements. + The object to locate in the list The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the first occurrence of item within the range of elements in the list that starts at index and contains count number of elements, if found; otherwise, -1. + + + Inserts the specified object into the immutable list at the specified index. + The zero-based index at which to insert the object. + The object to insert. + The new immutable list after the object is inserted. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which to insert the elements. + The collection whose elements should be inserted. + The new immutable list after the elements are inserted. + + + Gets a value that indicates whether this list is empty. + + if the list is empty; otherwise, . + + + Gets the element at the specified index of the list. + The index of the element to retrieve. + The element at the specified index. + In a get operation, is negative or not less than . + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + is negative or not less than . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the list that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the last occurrence of item within the range of elements in the list that contains count number of elements and ends at index, if found; otherwise, -1. + + + Removes the first occurrence of the specified object from this immutable list. + The object to remove. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes the first occurrence of the object that matches the specified value from this immutable list. + The value of the element to remove from the list. + The equality comparer to use in the search. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The new list with the elements removed. + + + Removes the element at the specified index. + The zero-based index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list. + The collection whose elements should be removed if matches are found in this list. + A new list with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new list with the elements removed. + + + Removes a range of elements, starting from the specified index and containing the specified number of elements, from this immutable list. + The starting index to begin removal. + The number of elements to remove. + A new list with the elements removed. + + + Replaces the specified element in the immutable list with a new element. + The element to replace. + The element to replace with. + The new list with the replaced element, even if it is equal to the old element. + + does not exist in the immutable list. + + + Replaces the specified element in the immutable list with a new element. + The element to replace in the list. + The element to replace with. + The comparer to use to check for equality. + A new list with the object replaced, or this list if the specified object is not in this list. + + + Reverses the order of the elements in the entire immutable list. + The reversed list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + The reversed list. + + + Replaces an element at a given position in the immutable list with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list with the replaced element, even if it is equal to the old element at that position. + + + Sorts the elements in the entire immutable list using the default comparer. + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The delegate to use when comparing elements. + The sorted list. + + is . + + + Sorts a range of elements in the immutable list using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Adds the specified item to the immutable list. + The item to add. + + + + Removes all items from the immutable list. + + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove. + + if was successfully removed from the list; otherwise, . This method also returns if is not found in the original list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Inserts an object in the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert. + + + + Gets or sets the value at the specified index. + + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the value at the specified index. + The zero-based index of the item to remove. + + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified array index. + The one-dimensional array that is the destination of the elements copied from immutable list. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Adds an item to the immutable list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the list. + Always thrown. + + + Removes all items from the immutable list. + Always thrown. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if the object is found in the list; otherwise, . + + + + Determines the index of a specific item in the immutable list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item into the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + Always thrown. + + + Gets a value indicating whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The value at the specified index. + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + Always thrown. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove. + Always thrown. + + + Adds the specified value to this immutable list. + The value to add. + A new list with the element added. + + + Adds the specified values to this immutable list. + The values to add. + A new list with the elements added. + + + Retrieves an empty list that has the same sorting and ordering semantics as this instance. + An empty list that has the same sorting and ordering semantics as this instance. + + + Inserts the specified element at the specified index in the immutable list. + The index at which to insert the value. + The element to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The index at which to insert the elements. + The elements to insert. + A new immutable list that includes the specified elements. + + + Removes the element with the specified value from the list. + The value of the element to remove from the list. + The comparer to use to compare elements for equality. + A new with the specified element removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list that match the items specified. + The range of items to remove from the list, if found. + The equality comparer to use to compare elements. + An immutable list with the items removed. + + or is . + + + Removes the specified number of elements at the specified location from this list. + The starting index of the range of elements to remove. + The number of elements to remove. + A new list with the elements removed. + + + Replaces an element in the list with the specified element. + The element to replace. + The element to replace the old element with. + The equality comparer to use in the search. + The new list. + Thrown when the old value does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list. + + + Creates a list that has the same contents as this list and can be efficiently mutated across multiple operations using standard mutable interfaces. + The created list with the same contents as this list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable queue. + The type of items to be stored in the immutable queue. + An empty immutable queue. + + + Creates a new immutable queue that contains the specified item. + The item to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified item. + + + Creates a new immutable queue that contains the specified array of items. + An array that contains the items to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified items. + + + Creates a new immutable queue that contains the specified items. + The items to add to the queue before immutability is applied. + The type of elements in the queue. + An immutable queue that contains the specified items. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + The queue to remove the item from. + When this method returns, contains the item from the beginning of the queue. + The type of elements in the immutable queue. + The new queue with the item removed. + The stack is empty. + + + Represents an immutable queue. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Removes all objects from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + The queue is empty. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + When this method returns, contains the element from the beginning of the queue. + The new immutable queue with the beginning element removed. + The queue is empty. + + + Gets an empty immutable queue. + An empty immutable queue. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Enumerates the contents of an immutable queue without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable queue. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the queue. + + + Returns an enumerator that iterates through the immutable queue. + An enumerator that can be used to iterate through the queue. + + + Gets a value that indicates whether this immutable queue is empty. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Gets a read-only reference to the element at the front of the queue. + The queue is empty. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates a new immutable sorted dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key comparer. + The comparer implementation to use to evaluate keys for equality and sorting. + The items to add to the sorted dictionary. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + The new immutable sorted dictionary that contains the specified items and uses the specified key comparer. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key and value comparers. + The comparer implementation to use to compare keys for equality and sorting. + The comparer implementation to use to compare values for equality and sorting. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items and uses the specified comparers. + + + Creates an immutable sorted dictionary that contains the specified items and uses the default comparer. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable sorted dictionary from the current contents of the builder's dictionary. + The builder to create the immutable sorted dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Represents an immutable sorted dictionary. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the key contained in the dictionary. + The type of the value contained in the dictionary. + + + Adds an element with the specified key and value to the immutable sorted dictionary. + The key of the entry to add. + The value of entry to add. + A new immutable sorted dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specific key/value pairs to the immutable sorted dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a sorted dictionary that mutates with little or no memory allocations and that can produce or build on immutable sorted dictionary instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable sorted dictionary. + The key of the element to add. + The value of the element to add. + + + Adds the specified item to the immutable sorted dictionary. + The object to add to the dictionary. + + + Adds a sequence of values to the immutable sorted dictionary. + The items to add to the dictionary. + + + Removes all items from the immutable sorted dictionary. + + + Determines whether the immutable sorted dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate in the dictionary. The value can be for reference types. + + if the immutable sorted dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements in this immutable sorted dictionary. + The number of elements in this dictionary. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the value for a specified key in the immutable sorted dictionary. + The key to retrieve the value for. + The value associated with the given key. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a strongly typed, read-only collection of elements. + A strongly typed, read-only collection of elements. + + + Removes the element with the specified key from the immutable sorted dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the original dictionary. + + + Removes the first occurrence of a specific object from the immutable sorted dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns if is not found in the dictionary. + + + Removes any entries with keys that match those found in the specified sequence from the immutable sorted dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable sorted dictionary based on the contents of this instance. + An immutable sorted dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + + Gets or sets the value comparer. + The value comparer. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets a collection that contains the values of the immutable sorted dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable sorted dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable sorted dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether this immutable sorted map contains the specified key. + The key to locate. + + if the immutable dictionary contains the specified key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable sorted dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable sorted dictionary. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable sorted dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted dictionary. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted dictionary. + + + The current element. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable sorted dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The key to retrieve the value for. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable sorted dictionary. + The key comparer for the dictionary. + + + Gets the keys in the immutable sorted dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified value from the immutable sorted dictionary. + The value of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified value cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable sorted dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable sorted dictionary, possibly overwriting an existing value for the given key. + The key of the entry to add. + The key value to set. + A new immutable sorted dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable sorted dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + An immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable sorted dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. + + if the dictionary contains an element with the specified key; otherwise, . + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets the values in the immutable sorted dictionary. + The values in the dictionary. + + + Gets an instance of the immutable sorted dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable sorted dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted set. + The type of items to be stored in the immutable set. + An empty immutable sorted set. + + + Creates a new immutable sorted set that contains the specified item. + The item to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Creates an empty immutable sorted set that uses the specified comparer. + The implementation to use when comparing items in the set. + The type of items in the immutable set. + An empty immutable set. + + + Creates a new immutable sorted set that contains the specified item and uses the specified comparer. + The implementation to use when comparing items in the set. + The item to prepopulate the set with. + The type of items stored in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items and uses the specified comparer. + The implementation to use when comparing items in the set. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Returns a collection that can be used to build an immutable sorted set. + The type of items stored by the collection. + The immutable collection builder. + + + Returns a collection that can be used to build an immutable sorted set. + The comparer used to compare items in the set for equality. + The type of items stored by the collection. + The immutable collection. + + + Creates a new immutable collection that contains the specified items. + The comparer to use to compare elements in this set. + The items to add to the set before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Creates a new immutable collection that contains the specified items. + The items to add to the set with before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Enumerates a sequence and produces an immutable sorted set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer. + The sequence to enumerate. + The comparer to use for initializing and adding members to the sorted set. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Creates an immutable sorted set from the current contents of the builder's set. + The builder to create the immutable sorted set from. + The type of the elements in the immutable sorted set. + An immutable sorted set that contains the current contents in the builder's set. + + + Represents an immutable sorted set implementation. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the set. + + + Adds the specified value to this immutable sorted set. + The value to add. + A new set with the element added, or this set if the element is already in this set. + + + Represents a sorted set that enables changes with little or no memory allocations, and efficiently manipulates or builds immutable sorted sets. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set + + + Removes all elements from this set. + + + Determines whether the set contains the specified object. + The object to locate in the set. + + if is found in the set; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in this set. + + + Removes the specified set of items from the current set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the set. + A enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection is compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the set at the given index. + The 0-based index of the element in the set to return. + The element at the given position. + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + + Gets or sets the object that is used to determine equality for the values in the immutable sorted set. + The comparer that is used to determine equality for the values in the set. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of the specified object from the set. + The object to remove from the set. + + if was removed from the set; if was not found in the set. + + + Returns an enumerator that iterates over the immutable sorted set in reverse order. + An enumerator that iterates over the set in reverse order. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread-safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Creates an immutable sorted set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current state. + + + Removes all elements from the immutable sorted set. + An empty set with the elements removed. + + + Determines whether this immutable sorted set contains the specified value. + The value to check for. + + if the set contains the specified value; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in the immutable sorted set. + + + Gets an empty immutable sorted set. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Advances the enumerator to the next element of the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted set. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + The current element. + + + Removes a specified set of items from this immutable sorted set. + The items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the immutable sorted set. + An enumerator that can be used to iterate through the set. + + + Gets the position within this immutable sorted set that the specified value appears in. + The value whose position is being sought. + The index of the specified in the sorted set, if is found. If is not found and is less than one or more elements in this set, this method returns a negative number that is the bitwise complement of the index of the first element that is larger than value. If is not found and is greater than any of the elements in the set, this method returns a negative number that is the bitwise complement of the index of the last element plus 1. + + + Creates an immutable sorted set that contains elements that exist both in this set and in the specified set. + The set to intersect with this one. + A new immutable sorted set that contains any elements that exist in both sets. + + + Gets a value that indicates whether this immutable sorted set is empty. + + if this set is empty; otherwise, . + + + Determines whether the current immutable sorted set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a proper superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current immutable sorted set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the immutable sorted set at the given index. + The index of the element to retrieve from the sorted set. + The element at the given index. + + + Gets a read-only reference of the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference of the element at the given position. + + + Gets the comparer used to sort keys in the immutable sorted set. + The comparer used to sort keys. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current immutable sorted set and a specified collection share common elements. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the specified value from this immutable sorted set. + The element to remove. + A new immutable sorted set with the element removed, or this set if the element was not found in the set. + + + Returns an that iterates over this immutable sorted set in reverse order. + An enumerator that iterates over the immutable sorted set in reverse order. + + + Determines whether the current immutable sorted set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable sorted set that contains elements that exist either in this set or in a given sequence, but not both. + The other sequence of items. + The new immutable sorted set. + + + Adds the specified value to the collection. + The value to add. + + + Removes all the items from the collection. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the collection. + The object to remove from the collection. + + if was successfully removed from the collection; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Inserts an item in the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + + + See the interface. + + + + Removes the item at the specified index. + The zero-based index of the item to remove. + + + Adds an element to the current set and returns a value to indicate if the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove from the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection + The collection to compare to the current set. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Adds an item to the set. + The object to add to the set. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + The set is read-only or has a fixed size. + + + Removes all items from the set. + Thrown in all cases. + + + Determines whether the set contains a specific value. + The object to locate in the set. + + if the object is found in the set; otherwise, . + + + Determines the index of a specific item in the set. + The object to locate in the set. + The index of if found in the list; otherwise, -1. + + + Inserts an item into the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + The set is read-only or has a fixed size. + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The . + + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + The set is read-only or has a fixed size. + + + Removes the item at the specified index of the set. + The zero-based index of the item to remove. + The set is read-only or has a fixed size. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Removes the elements in the specified collection from the current immutable set. + The items to remove from this set. + The new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates a collection that has the same contents as this immutable sorted set that can be efficiently manipulated by using standard mutable interfaces. + The sorted set builder. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Adds a given set of items to this immutable sorted set. + The items to add. + The new set with the items added; or the original set if all the items were already in the set. + + + Returns the immutable sorted set that has the specified key comparer. + The comparer to check for. + The immutable sorted set that has the specified key comparer. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable stack. + The type of items to be stored in the immutable stack. + An empty immutable stack. + + + Creates a new immutable stack that contains the specified item. + The item to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable collection that contains the specified item. + + + Creates a new immutable stack that contains the specified array of items. + An array that contains the items to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable stack that contains the specified items. + + + Creates a new immutable stack that contains the specified items. + The items to add to the stack before it's immutable. + The type of items in the stack. + An immutable stack that contains the specified items. + + + Removes the specified item from an immutable stack. + The stack to modify. + The item to remove from the stack. + The type of items contained in the stack. + A stack; never . + The stack is empty. + + + Represents an immutable stack. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element on the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets an empty immutable stack. + An empty immutable stack. + + + Enumerates the contents of an immutable stack without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable stack. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the stack. + + + Returns an enumerator that iterates through the immutable stack. + An enumerator that can be used to iterate through the stack. + + + Gets a value that indicates whether this instance of the immutable stack is empty. + + if this instance is empty; otherwise, . + + + Returns the object at the top of the stack without removing it. + The object at the top of the stack. + The stack is empty. + + + Gets a read-only reference to the element on the top of the stack. + A read-only reference to the element on the top of the stack. + Thrown when the stack is empty. + + + Removes the element at the top of the immutable stack and returns the stack after the removal. + A stack; never . + The stack is empty. + + + Removes the specified element from the immutable stack and returns the stack after the removal. + The value to remove from the stack. + A stack; never . + + + Inserts an object at the top of the immutable stack and returns the new stack. + The object to push onto the stack. + The new stack. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable stack. + The empty immutable stack. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never . + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + LINQ extension method overrides that offer greater efficiency for than the standard LINQ methods +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + A function to be invoked on each element, in a cumulative way. + The type of element contained by the collection. + The final value after the cumulative function has been applied to all elements. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + The type of the accumulated value. + The type of element contained by the collection. + The final accumulator value. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + + The type of the accumulated value. + The type of result returned by the result selector. + The type of element contained by the collection. + The final accumulator value. + + + Gets a value indicating whether all elements in this array match a given condition. + The array to check for matches. + The predicate. + The type of element contained by the collection. + + if every element of the source sequence passes the test in the specified predicate; otherwise, . + + + Gets a value indicating whether the array contains any elements. + The array to check for elements. + The type of element contained by the collection. + + if the array contains an elements; otherwise, . + + + Gets a value indicating whether the array contains any elements that match a specified condition. + The array to check for elements. + The delegate that defines the condition to match to an element. + The type of element contained by the collection. + + if an element matches the specified condition; otherwise, . + + + Returns a value indicating whether this collection contains any elements. + The builder to check for matches. + The type of elements in the array. + + if the array builder contains any elements; otherwise, . + + + Returns the element at a specified index in the array. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index. + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index, or the default value if the index is not found. + + + Returns the first element in an array. + The array to get an item from. + The type of element contained by the collection. + The first item in the array. + If the array is empty. + + + Returns the first element in a sequence that satisfies a specified condition. + The array to get an item from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list if it meets the condition specified by . + If the array is empty. + + + Returns the first element in the collection. + The builder to retrieve an item from. + The type of items in the array. + The first item in the list. + If the array is empty. + + + Returns the first element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve elements from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the last element of the array. + The array to retrieve items from. + The type of element contained by the array. + The last element in the array. + Thrown if the collection is empty. + + + Returns the last element of a sequence that satisfies a specified condition. + The array to retrieve elements from. + The delegate that defines the conditions of the element to retrieve. + The type of element contained by the collection. + The last element of the array that satisfies the condition. + Thrown if the collection is empty. + + + Returns the last element in the collection. + The builder to retrieve elements from. + The type of item in the builder. + The last element in the builder. + Thrown if the collection is empty. + + + Returns the last element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve an element from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Projects each element of a sequence into a new form. + The immutable array to select items from. + A transform function to apply to each element. + The type of element contained by the collection. + The type of the result element. + An whose elements are the result of invoking the transform function on each element of source. + + + Projects each element of a sequence to an , flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. + The immutable array. + A transform function to apply to each element of the input sequence. + A transform function to apply to each element of the intermediate sequence. + The type of the elements of . + The type of the intermediate elements collected by . + The type of the elements of the resulting sequence. + An whose elements are the result of invoking the one-to-many transform function on each element of and then mapping each of those sequence elements and their corresponding source element to a result element. + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence. + The array to retrieve the element from. + The type of element contained by the collection. + The element in the sequence. + + + Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists. + + + The type of element contained by the collection. + Returns . + + + Returns the only element of the array, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence. + The array. + The type of element contained by the collection. + The element in the array, or the default value if the array is empty. + + contains more than one element. + + + Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. + The array to get the element from. + The condition the element must satisfy. + The type of element contained by the collection. + The element if it satisfies the specified condition; otherwise the default element. + More than one element satisfies the condition in . + + + Copies the contents of this array to a mutable array. + + The type of element contained by the collection. + The newly instantiated array. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Filters a sequence of values based on a predicate. + The array to filter. + The condition to use for filtering the array content. + The type of element contained by the collection. + Returns that contains elements that meet the condition. + + + diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard2.0/System.Collections.Immutable.dll b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/netstandard2.0/System.Collections.Immutable.dll new file mode 100755 index 0000000000000000000000000000000000000000..679b9036c66f67e1cb5ca4b3c3dcafec55a1d10d GIT binary patch literal 180096 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 + + + System.Collections.Immutable + + + + Represents an immutable collection of key/value pairs. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of keys in the dictionary. + The type of values in the dictionary. + + + Adds an element with the specified key and value to the dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Retrieves an empty dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether the immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Represents a list of elements that cannot be modified. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Makes a copy of the list, and adds the specified object to the end of the copied list. + The object to add to the list. + A new list with the object added. + + + Makes a copy of the list and adds the specified objects to the end of the copied list. + The objects to add to the list. + A new list with the elements added. + + + Creates a list with all the items removed, but with the same sorting and ordering semantics as this list. + An empty list that has the same sorting and ordering semantics as this instance. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the . This value can be null for reference types. + The zero-based starting indexes of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use to locate . + The zero-based index of the first occurrence of within the range of elements in the that starts at and contains number of elements if found; otherwise -1. + + + Inserts the specified element at the specified index in the immutable list. + The zero-based index at which to insert the value. + The object to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The zero-based index at which the new elements should be inserted. + The elements to insert. + A new immutable list that includes the specified elements. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to match . + Returns . + + + Removes the first occurrence of a specified object from this immutable list. + The object to remove from the list. + The equality comparer to use to locate . + A new list with the specified object removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes the specified object from the list. + The objects to remove from the list. + The equality comparer to use to determine if match any objects in the list. + A new immutable list with the specified objects removed, if matched objects in the list. + + + Removes a range of elements from the . + The zero-based starting index of the range of elements to remove. + The number of elements to remove. + A new immutable list with the elements removed. + + + Returns a new list with the first matching element in the list replaced with the specified element. + The element to be replaced. + The element to replace the first occurrence of with + The equality comparer to use for matching . + A new list that contains , even if is the same as . + + does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + A new list that contains the new element, even if the element at the specified location is the same as the new element. + + + Represents an immutable first-in, first-out collection of objects. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Returns a new queue with all the elements removed. + An empty immutable queue. + + + Removes the first element in the immutable queue, and returns the new queue. + The new immutable queue with the first element removed. This value is never null. + The queue is empty. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue with the specified element added. + + + Gets a value that indicates whether this immutable queue is empty. + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Represents a set of elements that can only be modified by creating a new instance of the set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored in the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable set contains a specified element. + The element to locate in the set. + + if the set contains the specified value; otherwise, . + + + Removes the elements in the specified collection from the current immutable set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains only elements that exist in this set and the specified set. + The collection to compare to the current . + A new immutable set that contains elements that exist in both sets. + + + Determines whether the current immutable set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a proper (strict) superset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, false. + + + Determines whether the current immutable set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Determines whether the current immutable set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Determines whether the set contains a specified value. + The value to search for. + The matching value from the set, if found, or equalvalue if there are no matches. + + if a matching value was found; otherwise, . + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Represents an immutable last-in-first-out (LIFO) collection. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets a value that indicates whether this immutable stack is empty. + + if this stack is empty; otherwise,. + + + Returns the element at the top of the immutable stack without removing it. + The element at the top of the stack. + The stack is empty. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never null + The stack is empty. + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + Provides methods for creating an array that is immutable; meaning it cannot be changed once it is created. +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Searches the sorted immutable array for a specified element using the default comparer and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The comparer implementation to use when comparing elements, or null to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . + + is less than the lower bound of . +-or- + is less than zero. + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The comparer to use when comparing elements for equality or to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . +-or- + is , and is of a type that is not compatible with the elements of . + + is less than the lower bound of . +-or- + is less than zero. + + + Creates an empty immutable array. + The type of elements stored in the array. + An empty immutable array. + + + Creates an immutable array that contains the specified object. + The object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified object. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The fourth object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array from the specified array of objects. + The array of objects to populate the array with. + The type of elements stored in the array. + An immutable array that contains the array of items. + + + Creates an immutable array with specified objects from another array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates an immutable array with the specified objects from another immutable array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The initial capacity of the builder. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a new populated with the specified items. + The elements to add to the array. + The type of element stored in the array. + An immutable array that contains the specified items. + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + An argument to be passed to the selector mapping function. + + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + An argument to be passed to the selector mapping function. + + + + + + Creates an immutable array from the specified collection. + The collection of objects to copy to the immutable array. + The type of elements contained in . + An immutable array that contains the specified collection of objects. + + + Creates an immutable array from the current contents of the builder's array. + The builder to create the immutable array from. + The type of elements contained in the immutable array. + An immutable array that contains the current contents of the builder's array. + + + Represents an array that is immutable; meaning it cannot be changed once it is created. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored by the array. + + + Returns a copy of the original array with the specified item added to the end. + The item to be added to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a new immutable array that contains the elements of this array cast to a different type. + The type of array element to return. + An immutable array that contains the elements of this array, cast to a different type. If the cast fails, returns an array whose property returns . + + + Creates a new read-only memory region over this immutable array. + The read-only memory representation of this immutable array. + + + Creates a new read-only span over this immutable array. + The read-only span representation of this immutable array. + + + A writable array accessor that can be converted into an instance without allocating extra memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the array. + The object to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Gets or sets the length of the internal array. When set, the internal array is reallocated to the given capacity if it is not already the specified length. + The length of the internal array. + + + Removes all items from the array. + + + Determines whether the array contains a specific value. + The object to locate in the array. + + if the object is found; otherwise, . + + + Copies the current contents to the specified array. + The array to copy to. + The index to start the copy operation. + + + Gets or sets the number of items in the array. + The number of items in the array. + + + Gets an object that can be used to iterate through the collection. + An object that can be used to iterate through the collection. + + + Determines the index of a specific item in the array. + The item to locate in the array. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The number of elements to search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index for the specified item. + The item to locate in the array. + The index at which to begin the search. + The starting position of the search. + The equality comparer to use in the search + The index of if it's found in the list; otherwise, -1. + + + Inserts an item in the array at the specified index. + The zero-based index at which to insert the item. + The object to insert into the array. + + + Gets or sets the item at the specified index. + The index of the item to get or set. + The item at the specified index. + The specified index is not in the array. + + + Gets a read-only reference to the element at the specified index. + The item index. + The read-only reference to the element at the specified index. + + is greater or equal to the array count. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The 0-based index where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Extracts the internal array as an and replaces it with a zero length array. + When doesn't equal . + + + Removes the specified element. + The item to remove. + + if was found and removed; otherwise, . + + + Removes the item at the specified index from the array. + The zero-based index of the item to remove. + + + Reverses the order of elements in the collection. + + + Sorts the contents of the array. + + + Sorts the contents of the array. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Sorts the elements in the entire array using the specified . + The to use when comparing elements. + + is null. + + + Sorts the contents of the array. + The starting index for the sort. + The number of elements to include in the sort. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Creates a new array with the current contents of this . + A new array with the contents of this . + + + Returns an immutable array that contains the current contents of this . + An immutable array that contains the current contents of this . + + + Initializes a new instance of the struct by casting the underlying array to an array of type . + + Thrown if the cast is illegal. + + + Initializes a new instance of the struct based on the contents of an existing instance, allowing a covariant static cast to efficiently reuse the existing array. + The array to initialize the array with. No copy is made. + + + + Returns an array with all the elements removed. + An array with all of the elements removed. + + + Determines whether the specified item exists in the array. + The item to search for. + + if the specified item was found in the array; otherwise . + + + Copies the contents of this array to the specified array. + The array to copy to. + + + Copies the contents of this array to the specified array starting at the specified destination index. + The array to copy to. + The index in where copying begins. + + + Copies the specified items in this array to the specified array at the specified starting index. + The index of this array where copying begins. + The array to copy to. + The index in where copying begins. + The number of elements to copy from this array. + + + Gets an empty immutable array. + + + An array enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the current item. + The current item. + + + Advances to the next value in the array. + + if another item exists in the array; otherwise, . + + + Indicates whether specified array is equal to this array. + An object to compare with this object. + + if is equal to this array; otherwise, . + + + Determines if this array is equal to the specified object. + The to compare with this array. + + if this array is equal to ; otherwise, . + + + Returns an enumerator that iterates through the contents of the array. + An enumerator. + + + Returns a hash code for this instance. + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + Searches the array for the specified item. + The item to search for. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the item inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Gets a value indicating whether this array was declared but not initialized. + + if the is ; otherwise, . + + + Gets a value indicating whether this is empty or is not initialized. + + if the is or ; otherwise, . + + + Gets a value indicating whether this is empty. + + if the is empty; otherwise, . + + + Gets the element at the specified index in the immutable array. + The zero-based index of the element to get. + The element at the specified index in the immutable array. + + + Gets a read-only reference to the element at the specified in the read-only list. + The zero-based index of the element to get a reference to. + A read-only reference to the element at the specified in the read-only list. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Gets the number of elements in the array. + The number of elements in the array + + + Filters the elements of this array to those assignable to the specified type. + The type to filter the elements of the sequence on. + An that contains elements from the input sequence of type of . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates whether two arrays are not equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are not equal; otherwise, . + + + Checks for inequality between two array. + The object to the left of the operator. + The object to the right of the operator. + + if the two arrays are not equal; otherwise, . + + + Returns an array with the first occurrence of the specified element removed from the array. If no match is found, the current array is returned. + The item to remove. + A new array with the item removed. + + + Returns an array with the first occurrence of the specified element removed from the array. + If no match is found, the current array is returned. + The item to remove. + The equality comparer to use in the search. + A new array with the specified item removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the item at the specified index removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + A new array with the elements removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + A new list with the elements removed. + + + Removes the specified items from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The item to add to the list. + The new array that contains at the specified index. + + + Sorts the elements in the immutable array using the default comparer. + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the immutable array using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the entire using the specified . + The to use when comparing elements. + The sorted list. + + is null. + + + Sorts the specified elements in the immutable array using the specified comparer. + The index of the first element to sort. + The number of elements to include in the sort. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Throws in all cases. + The item to add to the end of the array. + + + Throws in all cases. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Throws in all cases. + The object to remove from the array. + Throws in all cases. + + + Returns an enumerator that iterates through the array. + An enumerator that can be used to iterate through the array. + + + Throws in all cases. + The index of the location to insert the item. + The item to insert. + + + Gets or sets the element at the specified index in the read-only list. + The zero-based index of the element to get. + The element at the specified index in the read-only list. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The index. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets the element at the specified index. + The index. + The element. + Thrown if the property returns true. + + + Copies this array to another array starting at the specified index. + The array to copy this array to. + The index in the destination array to start the copy operation. + + + Gets the size of the array. + Thrown if the property returns true. + + + See the interface. + + + Gets the sync root. + + + Returns an enumerator that iterates through the immutable array. + An enumerator that iterates through the immutable array. + The property returns . + + + Throws in all cases. + The value to add to the array. + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + The value to check for. + Throws in all cases. + + + Gets the value at the specified index. + The value to return the index of. + The value of the element at the specified index. + + + Throws in all cases. + Index that indicates where to insert the item. + The value to insert. + Thrown in all cases. + + + Gets a value indicating whether this instance is fixed size. + + true if this instance is fixed size; otherwise, false. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Gets or sets the at the specified index. + The index. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The value to remove from the array. + Thrown in all cases. + + + Throws in all cases. + The index of the item to remove. + Thrown in all cases. + + + Returns a copy of the original array with the specified item added to the end. + The value to add to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the end of the array. + A new array with the elements added to the end. + + + Returns an array with all the elements removed. + An array with all the elements removed. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the specified value inserted. + + + Inserts the specified values at the specified index + The index at which to insert the value. + The elements to insert. + A new array with the specified values inserted. + + + Returns an array with the first occurrence of the specified element removed from the array; if no match is found, the current array is returned. + The value to remove from the array. + The equality comparer to use in the search. + A new array with the value removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the specified item removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The value to add to the list. + The new array that contains at the specified index. + + + Determines whether the current collection element precedes, occurs in the same position as, or follows another element in the sort order. + The element to compare with the current instance. + The object used to compare members of the current array with the corresponding members of other array. + An integer that indicates whether the current element precedes, is in the same position or follows the other element. + The arrays are not the same length. + + + Determines whether this array is structurally equal to the specified array. + The array to compare with the current instance. + An object that determines whether the current instance and other are structurally equal. + + if the two arrays are structurally equal; otherwise, . + + + Returns a hash code for the current instance. + An object that computes the hash code of the current object. + The hash code for the current instance. + + + Creates a mutable array that has the same contents as this array and can be efficiently mutated across multiple operations using standard mutable interfaces. + The new builder with the same contents as this array. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Determines whether the specified immutable dictionary contains the specified key/value pair. + The immutable dictionary to search. + The key to locate in the immutable dictionary. + The value to locate on the specified key, if the key is found. + The type of the keys in the immutable dictionary. + The type of the values in the immutable dictionary. + + if this map contains the specified key/value pair; otherwise, . + + + Creates an empty immutable dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates a new immutable dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary that contains the specified items. + The items used to populate the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The comparer implementation to use to compare values for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The type of the key. + The type of the value. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The type of the key. + The type of the value. + The value for the key, or if no matching key was found. + + + Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Constructs an immutable dictionary based on some transformation of a sequence. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The key comparer to use for the dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable dictionary from the current contents of the builder's dictionary. + The builder to create the immutable dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Represents an immutable, unordered collection of keys and values. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the keys in the dictionary. + The type of the values in the dictionary. + + + Adds an element with the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the immutable dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a hash map that mutates with little or no memory allocations and that can produce or build on immutable hash map instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + + is null. + An element with the same key already exists in the dictionary. + The dictionary is read-only. + + + Adds the specified item to the immutable dictionary. + The object to add to the dictionary. + The dictionary is read-only. + + + Adds a sequence of values to this collection. + The items to add to this collection. + + + Removes all items from the immutable dictionary. + The dictionary is read-only. + + + Determines whether the immutable dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element that has the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + is null. + + + Determines whether the immutable dictionary contains an element that has the specified value. + The value to locate in the immutable dictionary. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements contained in the immutable dictionary. + The number of elements contained in the immutable dictionary. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the collection. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the element with the specified key. + The element to get or set. + The element that has the specified key. + + is . + The property is being retrieved, and is not found. + The property is being set, and the is read-only. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a collection that contains the keys of the immutable dictionary. + A collection that contains the keys of the object that implements the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the dictionary. + + is null. + The dictionary is read-only. + + + Removes the first occurrence of a specific object from the immutable dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns false if is not found in the dictionary. + The dictionary is read-only. + + + Removes any entries with keys that match those found in the specified sequence from the immutable dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array of type , starting at the specified array index. + The one-dimensional array of type that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable dictionary based on the contents of this instance. + An immutable dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Returns the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, returns the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the immutable dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets or sets the value comparer. + The value comparer. + + + Gets a collection that contains the values of the immutable dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified key. + The key to locate. + + if the immutable dictionary contains an element with the specified key; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable dictionary + + + Enumerates the contents of the immutable dictionary without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element in the dictionary at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the dictionary. + The dictionary was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the dictionary. + The dictionary was modified after the enumerator was created. + + + Gets the current element. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The type of the key. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable dictionary. + The key comparer. + + + Gets the keys in the immutable dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the immutable dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Gets the values in the immutable dictionary. + The values in the immutable dictionary. + + + Gets an instance of the immutable dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable hash set. + The type of items to be stored in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the specified array of items. + An array that contains the items to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates an empty immutable hash set that uses the specified equality comparer. + The object to use for comparing objects in the set for equality. + The type of items in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the items in the specified collection and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + An array that contains the items to prepopulate the hash set with. + The type of items stored in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates a new immutable hash set builder. + The type of items stored by the collection. + The immutable hash set builder. + + + Creates a new immutable hash set builder. + The object to use for comparing objects in the set for equality. + The type of items stored by the collection. + The new immutable hash set builder. + + + Creates a new immutable hash set prefilled with the specified items. + The items to add to the hash set. + The type of items stored by the collection. + The new immutable hash set that contains the specified items. + + + Creates a new immutable hash set that contains the specified items and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The items add to the collection before immutability is applied. + The type of items stored in the collection. + The new immutable hash set. + + + Enumerates a sequence and produces an immutable hash set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type. + The sequence to enumerate. + The object to use for comparing objects in the set for equality. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence and uses the specified equality comparer. + + + Creates an immutable hash set from the current contents of the builder's set. + The builder to create the immutable hash set from. + The type of the elements in the hash set. + An immutable hash set that contains the current contents in the builder's set. + + + Represents an immutable, unordered hash set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the hash set. + + + Adds the specified element to the hash set. + The element to add to the set. + A hash set that contains the added value and any values previously held by the object. + + + Represents a hash set that mutates with little or no memory allocations and that can produce or build on immutable hash set instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the immutable hash set. + The item to add. + + if the item did not already belong to the collection; otherwise, . + + + Removes all items from the immutable hash set. + The hash set is read-only. + + + Determines whether the immutable hash set contains a specific value. + The object to locate in the hash set. + + if is found in the hash set ; otherwise, . + + + Gets the number of elements contained in the immutable hash set. + The number of elements contained in the immutable hash set. + + + Removes all elements in the specified collection from the current hash set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the immutable hash set. + An enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets or sets the key comparer. + The key comparer. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of a specific object from the immutable hash set. + The object to remove from the set. + + if was successfully removed from the set ; otherwise, . This method also returns if is not found in the original set. + The set is read-only. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an item to the hash set. + The object to add to the set. + The set is read-only. + + + Copies the elements of the hash set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the hash set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current set. + + + Retrieves an empty immutable hash set that has the same sorting and ordering semantics as this instance. + An empty hash set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable hash set contains the specified element. + The object to locate in the immutable hash set. + + if is found in the ; otherwise, . + + + Gets the number of elements in the immutable hash set. + The number of elements in the hash set. + + + Gets an immutable hash set for this type that uses the default . + + + Enumerates the contents of the immutable hash set without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable hash set. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the hash set. + The hash set was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the hash set. + The hash set was modified after the enumerator was created. + + + Gets the current element. + + + Removes the elements in the specified collection from the current immutable hash set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Gets a value that indicates whether the current immutable hash set is empty. + + if this instance is empty; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Gets the object that is used to obtain hash codes for the keys and to check the equality of values in the immutable hash set. + The comparer used to obtain hash codes for the keys and check equality. + + + Determines whether the current immutable hash set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable hash set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable hash set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable hash set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Adds an item to the set. + The object to add to the set. + The set is read-only. + + + Removes all items from this set. + The set is read-only. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + + if the element is successfully removed; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that iterates through the collection. + + + Adds an element to the current set and returns a value that indicates whether the element was successfully added. + The element to add to the collection. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current collection. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or in the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a set. + An enumerator that can be used to iterate through the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting or ordering semantics as this instance. + + + Removes the elements in the specified collection from the current set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates an immutable hash set that has the same contents as this set and can be efficiently mutated across multiple operations by using standard mutable interfaces. + A set with the same contents as this set that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Creates a new immutable hash set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable hash set with the items added; or the original set if all the items were already in the set. + + + Gets an instance of the immutable hash set that uses the specified equality comparer for its search methods. + The equality comparer to use. + An instance of this immutable hash set that uses the given comparer. + + + Contains interlocked exchange mechanisms for immutable collections. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The value to use if no previous value exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The function that receives the key and returns a new value to add to the dictionary when no value previously exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Atomically enqueues an element to the end of a queue. + The variable or field to atomically update. + The value to enqueue. + The type of items contained in the collection + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified key is not in the dictionary. + The key for the value to get or add. + The value to add to the dictionary the key is not found. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. This delegate will not be invoked more than once. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. + The argument to pass to the value factory. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The type of the argument supplied to the value factory. + The value at the specified key or if the key was not present. + + + Compares two immutable arrays for equality and, if they are equal, replaces one of the arrays. + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The type of element stored by the array. + The original value in . + + + Sets an array to the specified array and returns a reference to the original array, as an atomic operation. + The array to set to the specified value. + The value to which the parameter is set. + The type of element stored by the array. + The original value of . + + + Sets an array to the specified array if the array has not been initialized. + The array to set to the specified value. + The value to which the parameter is set, if it's not initialized. + The type of element stored by the array. + + if the array was assigned the specified value; otherwise, . + + + Pushes a new element onto the stack. + The stack to update. + The value to push on the stack. + The type of items in the stack. + + + Adds the specified key and value to the dictionary if the key is not in the dictionary. + The dictionary to update with the specified key and value. + The key to add, if is not already defined in the dictionary. + The value to add. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key is not in the dictionary; otherwise, . + + + Atomically removes and returns the specified element at the head of the queue, if the queue is not empty. + The variable or field to atomically update. + Set to the value from the head of the queue, if the queue not empty. + The type of items in the queue. + + if the queue is not empty and the head element is removed; otherwise, . + + + Removes an element from the top of the stack, if there is an element to remove. + The stack to update. + Receives the value removed from the stack, if the stack is not empty. + The type of items in the stack. + + if an element is removed from the stack; otherwise, . + + + Removes the element with the specified key, if the key exists. + The dictionary to update. + The key to remove. + Receives the value of the removed item, if the dictionary is not empty. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key was found and removed; otherwise, . + + + Sets the specified key to the specified value if the specified key already is set to a specific value. + The dictionary to update. + The key to update. + The new value to set. + The current value for in order for the update to succeed. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if and are present in the dictionary and comparison was updated to ; otherwise, . + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The type of data. + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The argument to pass to . + The type of data. + The type of argument passed to the . + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable list. + The type of items to be stored in the . + An empty immutable list. + + + Creates a new immutable list that contains the specified item. + The item to prepopulate the list with. + The type of items in the . + A new that contains the specified item. + + + Creates a new immutable list that contains the specified array of items. + An array that contains the items to prepopulate the list with. + The type of items in the . + A new immutable list that contains the specified items. + + + Creates a new immutable list builder. + The type of items stored by the collection. + The immutable collection builder. + + + Creates a new immutable list that contains the specified items. + The items to add to the list. + The type of items in the . + An immutable list that contains the specified items. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Removes the specified value from this list. + The list to search. + The value to remove. + The type of items in the list. + A new immutable list with the element removed, or this list if the element is not in this list. + + + Removes the specified values from this list. + The list to search. + The items to remove if matches are found in this list. + The type of items in the list. + A new immutable list with the elements removed. + + + Replaces the first equal element in the list with the specified element. + The list to search. + The element to replace. + The element to replace the old element with. + The type of items in the list. + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + Enumerates a sequence and produces an immutable list of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable list that contains the items in the specified sequence. + + + Creates an immutable list from the current contents of the builder's collection. + The builder to create the immutable list from. + The type of the elements in the list. + An immutable list that contains the current contents in the builder's collection. + + + Represents an immutable list, which is a strongly typed list of objects that can be accessed by index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Adds the specified object to the end of the immutable list. + The object to add. + A new immutable list with the object added. + + + Adds the elements of the specified collection to the end of the immutable list. + The collection whose elements will be added to the end of the list. + A new immutable list with the elements added. + + + Searches the entire sorted list for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be for reference types. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + The default comparer cannot find a comparer implementation of the for type T. + + + Searches the entire sorted list for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements or null to use the default comparer. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + comparer is , and the default comparer cannot find an comparer implementation for type T. + + + Searches a range of elements in the sorted list for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements, or to use the default comparer. + The zero-based index of item in the sorted list, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + index is less than 0 or is less than 0. + index and do not denote a valid range in the list. + + is , and the default comparer cannot find an comparer implementation for type T. + + + Represents a list that mutates with little or no memory allocations and that can produce or build on immutable list instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an item to the immutable list. + The item to add to the list. + + + Adds a series of elements to the end of this list. + The elements to add to the end of the list. + + + Searches the entire for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + The default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the entire for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the specified range of the for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is less than 0. +-or- + is less than 0. + + and do not denote a valid range in the . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Removes all items from the immutable list. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if item is found in the list; otherwise, . + + + Creates a new immutable list from the list represented by this builder by using the converter function. + The converter function. + The type of the output of the delegate converter function. + A new immutable list from the list represented by this builder. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + The number of elements to copy. + + + Gets the number of elements in this immutable list. + The number of elements in this list. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Performs the specified action on each element of the list. + The delegate to perform on each element of the list. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the first occurrence of within the range of elements in the immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Inserts an item to the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the immutable list. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which the new elements should be inserted. + The collection whose elements should be inserted into the immutable list. The collection itself cannot be , but it can contain elements that are null, if type T is a reference type. + + + Gets or sets the value for a given index in the list. + The index of the item to get or set. + The value at the specified index. + + + Gets a read-only reference to the value for a given into the list. + The index of the desired element. + A read-only reference to the value at the specified . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the last occurrence of within the entire immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that extends from the first element to , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that contains number of elements and ends at , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + + if item was successfully removed from the list; otherwise, . This method also returns if item is not found in the list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The number of elements removed from the immutable list. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove from the list. + + + Reverses the order of the elements in the entire immutable list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + + + Sorts the elements in the entire immutable list by using the default comparer. + + + Sorts the elements in the entire immutable list by using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + + + Sorts the elements in the entire immutable list by using the specified comparison object. + The object to use when comparing elements. + + is . + + + Sorts the elements in a range of elements in the immutable list by using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Copies the elements of the list to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Adds an item to the list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + + + + Removes all items from the list. + + + + Determines whether the list contains a specific value. + The object to locate in the list. + + if the is found in the list; otherwise, . + + + + Determines the index of a specific item in the list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item to the list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + + + Removes the first occurrence of a specific object from the list. + The object to remove from the list. + + + + Creates an immutable list based on the contents of this instance. + An immutable list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Removes all elements from the immutable list. + An empty list that retains the same sort or unordered semantics that this instance has. + + + Determines whether this immutable list contains the specified value. + The value to locate. + + if the list contains the specified value; otherwise, . + + + Converts the elements in the current immutable list to another type, and returns a list containing the converted elements. + A delegate that converts each element from one type to another type. + The type of the elements of the target array. + A list of the target type containing the converted elements from the current . + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Copies a range of elements from the immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + The number of elements to copy. + + + Gets the number of elements contained in the list. + The number of elements in the list. + + + Gets an empty set with the default sort comparer. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances enumeration to the next element of the immutable list. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the list. + + + Sets the enumerator to its initial position, which is before the first element in the immutable list. + + + The current element. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list that contains all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Performs the specified action on each element of the immutable list. + The delegate to perform on each element of the immutable list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the immutable list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be null for reference types. + The zero-based index of the first occurrence of within the entire immutable list, if found; otherwise, ?1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the list that starts at the specified index and contains the specified number of elements. + The object to locate in the list The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the first occurrence of item within the range of elements in the list that starts at index and contains count number of elements, if found; otherwise, -1. + + + Inserts the specified object into the immutable list at the specified index. + The zero-based index at which to insert the object. + The object to insert. + The new immutable list after the object is inserted. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which to insert the elements. + The collection whose elements should be inserted. + The new immutable list after the elements are inserted. + + + Gets a value that indicates whether this list is empty. + + if the list is empty; otherwise, . + + + Gets the element at the specified index of the list. + The index of the element to retrieve. + The element at the specified index. + In a get operation, is negative or not less than . + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + is negative or not less than . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the list that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the last occurrence of item within the range of elements in the list that contains count number of elements and ends at index, if found; otherwise, -1. + + + Removes the first occurrence of the specified object from this immutable list. + The object to remove. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes the first occurrence of the object that matches the specified value from this immutable list. + The value of the element to remove from the list. + The equality comparer to use in the search. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The new list with the elements removed. + + + Removes the element at the specified index. + The zero-based index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list. + The collection whose elements should be removed if matches are found in this list. + A new list with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new list with the elements removed. + + + Removes a range of elements, starting from the specified index and containing the specified number of elements, from this immutable list. + The starting index to begin removal. + The number of elements to remove. + A new list with the elements removed. + + + Replaces the specified element in the immutable list with a new element. + The element to replace. + The element to replace with. + The new list with the replaced element, even if it is equal to the old element. + + does not exist in the immutable list. + + + Replaces the specified element in the immutable list with a new element. + The element to replace in the list. + The element to replace with. + The comparer to use to check for equality. + A new list with the object replaced, or this list if the specified object is not in this list. + + + Reverses the order of the elements in the entire immutable list. + The reversed list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + The reversed list. + + + Replaces an element at a given position in the immutable list with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list with the replaced element, even if it is equal to the old element at that position. + + + Sorts the elements in the entire immutable list using the default comparer. + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The delegate to use when comparing elements. + The sorted list. + + is . + + + Sorts a range of elements in the immutable list using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Adds the specified item to the immutable list. + The item to add. + + + + Removes all items from the immutable list. + + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove. + + if was successfully removed from the list; otherwise, . This method also returns if is not found in the original list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Inserts an object in the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert. + + + + Gets or sets the value at the specified index. + + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the value at the specified index. + The zero-based index of the item to remove. + + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified array index. + The one-dimensional array that is the destination of the elements copied from immutable list. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Adds an item to the immutable list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the list. + Always thrown. + + + Removes all items from the immutable list. + Always thrown. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if the object is found in the list; otherwise, . + + + + Determines the index of a specific item in the immutable list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item into the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + Always thrown. + + + Gets a value indicating whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The value at the specified index. + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + Always thrown. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove. + Always thrown. + + + Adds the specified value to this immutable list. + The value to add. + A new list with the element added. + + + Adds the specified values to this immutable list. + The values to add. + A new list with the elements added. + + + Retrieves an empty list that has the same sorting and ordering semantics as this instance. + An empty list that has the same sorting and ordering semantics as this instance. + + + Inserts the specified element at the specified index in the immutable list. + The index at which to insert the value. + The element to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The index at which to insert the elements. + The elements to insert. + A new immutable list that includes the specified elements. + + + Removes the element with the specified value from the list. + The value of the element to remove from the list. + The comparer to use to compare elements for equality. + A new with the specified element removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list that match the items specified. + The range of items to remove from the list, if found. + The equality comparer to use to compare elements. + An immutable list with the items removed. + + or is . + + + Removes the specified number of elements at the specified location from this list. + The starting index of the range of elements to remove. + The number of elements to remove. + A new list with the elements removed. + + + Replaces an element in the list with the specified element. + The element to replace. + The element to replace the old element with. + The equality comparer to use in the search. + The new list. + Thrown when the old value does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list. + + + Creates a list that has the same contents as this list and can be efficiently mutated across multiple operations using standard mutable interfaces. + The created list with the same contents as this list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable queue. + The type of items to be stored in the immutable queue. + An empty immutable queue. + + + Creates a new immutable queue that contains the specified item. + The item to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified item. + + + Creates a new immutable queue that contains the specified array of items. + An array that contains the items to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified items. + + + Creates a new immutable queue that contains the specified items. + The items to add to the queue before immutability is applied. + The type of elements in the queue. + An immutable queue that contains the specified items. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + The queue to remove the item from. + When this method returns, contains the item from the beginning of the queue. + The type of elements in the immutable queue. + The new queue with the item removed. + The stack is empty. + + + Represents an immutable queue. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Removes all objects from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + The queue is empty. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + When this method returns, contains the element from the beginning of the queue. + The new immutable queue with the beginning element removed. + The queue is empty. + + + Gets an empty immutable queue. + An empty immutable queue. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Enumerates the contents of an immutable queue without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable queue. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the queue. + + + Returns an enumerator that iterates through the immutable queue. + An enumerator that can be used to iterate through the queue. + + + Gets a value that indicates whether this immutable queue is empty. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Gets a read-only reference to the element at the front of the queue. + The queue is empty. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates a new immutable sorted dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key comparer. + The comparer implementation to use to evaluate keys for equality and sorting. + The items to add to the sorted dictionary. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + The new immutable sorted dictionary that contains the specified items and uses the specified key comparer. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key and value comparers. + The comparer implementation to use to compare keys for equality and sorting. + The comparer implementation to use to compare values for equality and sorting. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items and uses the specified comparers. + + + Creates an immutable sorted dictionary that contains the specified items and uses the default comparer. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable sorted dictionary from the current contents of the builder's dictionary. + The builder to create the immutable sorted dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Represents an immutable sorted dictionary. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the key contained in the dictionary. + The type of the value contained in the dictionary. + + + Adds an element with the specified key and value to the immutable sorted dictionary. + The key of the entry to add. + The value of entry to add. + A new immutable sorted dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specific key/value pairs to the immutable sorted dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a sorted dictionary that mutates with little or no memory allocations and that can produce or build on immutable sorted dictionary instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable sorted dictionary. + The key of the element to add. + The value of the element to add. + + + Adds the specified item to the immutable sorted dictionary. + The object to add to the dictionary. + + + Adds a sequence of values to the immutable sorted dictionary. + The items to add to the dictionary. + + + Removes all items from the immutable sorted dictionary. + + + Determines whether the immutable sorted dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate in the dictionary. The value can be for reference types. + + if the immutable sorted dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements in this immutable sorted dictionary. + The number of elements in this dictionary. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the value for a specified key in the immutable sorted dictionary. + The key to retrieve the value for. + The value associated with the given key. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a strongly typed, read-only collection of elements. + A strongly typed, read-only collection of elements. + + + Removes the element with the specified key from the immutable sorted dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the original dictionary. + + + Removes the first occurrence of a specific object from the immutable sorted dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns if is not found in the dictionary. + + + Removes any entries with keys that match those found in the specified sequence from the immutable sorted dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable sorted dictionary based on the contents of this instance. + An immutable sorted dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + + Gets or sets the value comparer. + The value comparer. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets a collection that contains the values of the immutable sorted dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable sorted dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable sorted dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether this immutable sorted map contains the specified key. + The key to locate. + + if the immutable dictionary contains the specified key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable sorted dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable sorted dictionary. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable sorted dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted dictionary. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted dictionary. + + + The current element. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable sorted dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The key to retrieve the value for. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable sorted dictionary. + The key comparer for the dictionary. + + + Gets the keys in the immutable sorted dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified value from the immutable sorted dictionary. + The value of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified value cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable sorted dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable sorted dictionary, possibly overwriting an existing value for the given key. + The key of the entry to add. + The key value to set. + A new immutable sorted dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable sorted dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + An immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable sorted dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. + + if the dictionary contains an element with the specified key; otherwise, . + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets the values in the immutable sorted dictionary. + The values in the dictionary. + + + Gets an instance of the immutable sorted dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable sorted dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted set. + The type of items to be stored in the immutable set. + An empty immutable sorted set. + + + Creates a new immutable sorted set that contains the specified item. + The item to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Creates an empty immutable sorted set that uses the specified comparer. + The implementation to use when comparing items in the set. + The type of items in the immutable set. + An empty immutable set. + + + Creates a new immutable sorted set that contains the specified item and uses the specified comparer. + The implementation to use when comparing items in the set. + The item to prepopulate the set with. + The type of items stored in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items and uses the specified comparer. + The implementation to use when comparing items in the set. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Returns a collection that can be used to build an immutable sorted set. + The type of items stored by the collection. + The immutable collection builder. + + + Returns a collection that can be used to build an immutable sorted set. + The comparer used to compare items in the set for equality. + The type of items stored by the collection. + The immutable collection. + + + Creates a new immutable collection that contains the specified items. + The comparer to use to compare elements in this set. + The items to add to the set before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Creates a new immutable collection that contains the specified items. + The items to add to the set with before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Enumerates a sequence and produces an immutable sorted set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer. + The sequence to enumerate. + The comparer to use for initializing and adding members to the sorted set. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Creates an immutable sorted set from the current contents of the builder's set. + The builder to create the immutable sorted set from. + The type of the elements in the immutable sorted set. + An immutable sorted set that contains the current contents in the builder's set. + + + Represents an immutable sorted set implementation. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the set. + + + Adds the specified value to this immutable sorted set. + The value to add. + A new set with the element added, or this set if the element is already in this set. + + + Represents a sorted set that enables changes with little or no memory allocations, and efficiently manipulates or builds immutable sorted sets. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set + + + Removes all elements from this set. + + + Determines whether the set contains the specified object. + The object to locate in the set. + + if is found in the set; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in this set. + + + Removes the specified set of items from the current set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the set. + A enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection is compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the set at the given index. + The 0-based index of the element in the set to return. + The element at the given position. + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + + Gets or sets the object that is used to determine equality for the values in the immutable sorted set. + The comparer that is used to determine equality for the values in the set. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of the specified object from the set. + The object to remove from the set. + + if was removed from the set; if was not found in the set. + + + Returns an enumerator that iterates over the immutable sorted set in reverse order. + An enumerator that iterates over the set in reverse order. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread-safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Creates an immutable sorted set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current state. + + + Removes all elements from the immutable sorted set. + An empty set with the elements removed. + + + Determines whether this immutable sorted set contains the specified value. + The value to check for. + + if the set contains the specified value; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in the immutable sorted set. + + + Gets an empty immutable sorted set. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Advances the enumerator to the next element of the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted set. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + The current element. + + + Removes a specified set of items from this immutable sorted set. + The items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the immutable sorted set. + An enumerator that can be used to iterate through the set. + + + Gets the position within this immutable sorted set that the specified value appears in. + The value whose position is being sought. + The index of the specified in the sorted set, if is found. If is not found and is less than one or more elements in this set, this method returns a negative number that is the bitwise complement of the index of the first element that is larger than value. If is not found and is greater than any of the elements in the set, this method returns a negative number that is the bitwise complement of the index of the last element plus 1. + + + Creates an immutable sorted set that contains elements that exist both in this set and in the specified set. + The set to intersect with this one. + A new immutable sorted set that contains any elements that exist in both sets. + + + Gets a value that indicates whether this immutable sorted set is empty. + + if this set is empty; otherwise, . + + + Determines whether the current immutable sorted set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a proper superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current immutable sorted set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the immutable sorted set at the given index. + The index of the element to retrieve from the sorted set. + The element at the given index. + + + Gets a read-only reference of the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference of the element at the given position. + + + Gets the comparer used to sort keys in the immutable sorted set. + The comparer used to sort keys. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current immutable sorted set and a specified collection share common elements. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the specified value from this immutable sorted set. + The element to remove. + A new immutable sorted set with the element removed, or this set if the element was not found in the set. + + + Returns an that iterates over this immutable sorted set in reverse order. + An enumerator that iterates over the immutable sorted set in reverse order. + + + Determines whether the current immutable sorted set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable sorted set that contains elements that exist either in this set or in a given sequence, but not both. + The other sequence of items. + The new immutable sorted set. + + + Adds the specified value to the collection. + The value to add. + + + Removes all the items from the collection. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the collection. + The object to remove from the collection. + + if was successfully removed from the collection; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Inserts an item in the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + + + See the interface. + + + + Removes the item at the specified index. + The zero-based index of the item to remove. + + + Adds an element to the current set and returns a value to indicate if the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove from the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection + The collection to compare to the current set. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Adds an item to the set. + The object to add to the set. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + The set is read-only or has a fixed size. + + + Removes all items from the set. + Thrown in all cases. + + + Determines whether the set contains a specific value. + The object to locate in the set. + + if the object is found in the set; otherwise, . + + + Determines the index of a specific item in the set. + The object to locate in the set. + The index of if found in the list; otherwise, -1. + + + Inserts an item into the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + The set is read-only or has a fixed size. + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The . + + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + The set is read-only or has a fixed size. + + + Removes the item at the specified index of the set. + The zero-based index of the item to remove. + The set is read-only or has a fixed size. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Removes the elements in the specified collection from the current immutable set. + The items to remove from this set. + The new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates a collection that has the same contents as this immutable sorted set that can be efficiently manipulated by using standard mutable interfaces. + The sorted set builder. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Adds a given set of items to this immutable sorted set. + The items to add. + The new set with the items added; or the original set if all the items were already in the set. + + + Returns the immutable sorted set that has the specified key comparer. + The comparer to check for. + The immutable sorted set that has the specified key comparer. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable stack. + The type of items to be stored in the immutable stack. + An empty immutable stack. + + + Creates a new immutable stack that contains the specified item. + The item to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable collection that contains the specified item. + + + Creates a new immutable stack that contains the specified array of items. + An array that contains the items to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable stack that contains the specified items. + + + Creates a new immutable stack that contains the specified items. + The items to add to the stack before it's immutable. + The type of items in the stack. + An immutable stack that contains the specified items. + + + Removes the specified item from an immutable stack. + The stack to modify. + The item to remove from the stack. + The type of items contained in the stack. + A stack; never . + The stack is empty. + + + Represents an immutable stack. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element on the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets an empty immutable stack. + An empty immutable stack. + + + Enumerates the contents of an immutable stack without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable stack. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the stack. + + + Returns an enumerator that iterates through the immutable stack. + An enumerator that can be used to iterate through the stack. + + + Gets a value that indicates whether this instance of the immutable stack is empty. + + if this instance is empty; otherwise, . + + + Returns the object at the top of the stack without removing it. + The object at the top of the stack. + The stack is empty. + + + Gets a read-only reference to the element on the top of the stack. + A read-only reference to the element on the top of the stack. + Thrown when the stack is empty. + + + Removes the element at the top of the immutable stack and returns the stack after the removal. + A stack; never . + The stack is empty. + + + Removes the specified element from the immutable stack and returns the stack after the removal. + The value to remove from the stack. + A stack; never . + + + Inserts an object at the top of the immutable stack and returns the new stack. + The object to push onto the stack. + The new stack. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable stack. + The empty immutable stack. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never . + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + LINQ extension method overrides that offer greater efficiency for than the standard LINQ methods +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + A function to be invoked on each element, in a cumulative way. + The type of element contained by the collection. + The final value after the cumulative function has been applied to all elements. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + The type of the accumulated value. + The type of element contained by the collection. + The final accumulator value. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + + The type of the accumulated value. + The type of result returned by the result selector. + The type of element contained by the collection. + The final accumulator value. + + + Gets a value indicating whether all elements in this array match a given condition. + The array to check for matches. + The predicate. + The type of element contained by the collection. + + if every element of the source sequence passes the test in the specified predicate; otherwise, . + + + Gets a value indicating whether the array contains any elements. + The array to check for elements. + The type of element contained by the collection. + + if the array contains an elements; otherwise, . + + + Gets a value indicating whether the array contains any elements that match a specified condition. + The array to check for elements. + The delegate that defines the condition to match to an element. + The type of element contained by the collection. + + if an element matches the specified condition; otherwise, . + + + Returns a value indicating whether this collection contains any elements. + The builder to check for matches. + The type of elements in the array. + + if the array builder contains any elements; otherwise, . + + + Returns the element at a specified index in the array. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index. + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index, or the default value if the index is not found. + + + Returns the first element in an array. + The array to get an item from. + The type of element contained by the collection. + The first item in the array. + If the array is empty. + + + Returns the first element in a sequence that satisfies a specified condition. + The array to get an item from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list if it meets the condition specified by . + If the array is empty. + + + Returns the first element in the collection. + The builder to retrieve an item from. + The type of items in the array. + The first item in the list. + If the array is empty. + + + Returns the first element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve elements from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the last element of the array. + The array to retrieve items from. + The type of element contained by the array. + The last element in the array. + Thrown if the collection is empty. + + + Returns the last element of a sequence that satisfies a specified condition. + The array to retrieve elements from. + The delegate that defines the conditions of the element to retrieve. + The type of element contained by the collection. + The last element of the array that satisfies the condition. + Thrown if the collection is empty. + + + Returns the last element in the collection. + The builder to retrieve elements from. + The type of item in the builder. + The last element in the builder. + Thrown if the collection is empty. + + + Returns the last element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve an element from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Projects each element of a sequence into a new form. + The immutable array to select items from. + A transform function to apply to each element. + The type of element contained by the collection. + The type of the result element. + An whose elements are the result of invoking the transform function on each element of source. + + + Projects each element of a sequence to an , flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. + The immutable array. + A transform function to apply to each element of the input sequence. + A transform function to apply to each element of the intermediate sequence. + The type of the elements of . + The type of the intermediate elements collected by . + The type of the elements of the resulting sequence. + An whose elements are the result of invoking the one-to-many transform function on each element of and then mapping each of those sequence elements and their corresponding source element to a result element. + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence. + The array to retrieve the element from. + The type of element contained by the collection. + The element in the sequence. + + + Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists. + + + The type of element contained by the collection. + Returns . + + + Returns the only element of the array, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence. + The array. + The type of element contained by the collection. + The element in the array, or the default value if the array is empty. + + contains more than one element. + + + Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. + The array to get the element from. + The condition the element must satisfy. + The type of element contained by the collection. + The element if it satisfies the specified condition; otherwise the default element. + More than one element satisfies the condition in . + + + Copies the contents of this array to a mutable array. + + The type of element contained by the collection. + The newly instantiated array. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Filters a sequence of values based on a predicate. + The array to filter. + The condition to use for filtering the array content. + The type of element contained by the collection. + Returns that contains elements that meet the condition. + + + diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.dll b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.dll new file mode 100755 index 0000000000000000000000000000000000000000..5f1ac196481fe0612bb6aa32e7873b47f3815392 GIT binary patch literal 180088 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 literal 0 HcmV?d00001 diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.xml b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.xml new file mode 100755 index 0000000..088230d --- /dev/null +++ b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.xml @@ -0,0 +1,5141 @@ + + + + System.Collections.Immutable + + + + Represents an immutable collection of key/value pairs. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of keys in the dictionary. + The type of values in the dictionary. + + + Adds an element with the specified key and value to the dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Retrieves an empty dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether the immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Represents a list of elements that cannot be modified. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Makes a copy of the list, and adds the specified object to the end of the copied list. + The object to add to the list. + A new list with the object added. + + + Makes a copy of the list and adds the specified objects to the end of the copied list. + The objects to add to the list. + A new list with the elements added. + + + Creates a list with all the items removed, but with the same sorting and ordering semantics as this list. + An empty list that has the same sorting and ordering semantics as this instance. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the . This value can be null for reference types. + The zero-based starting indexes of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use to locate . + The zero-based index of the first occurrence of within the range of elements in the that starts at and contains number of elements if found; otherwise -1. + + + Inserts the specified element at the specified index in the immutable list. + The zero-based index at which to insert the value. + The object to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The zero-based index at which the new elements should be inserted. + The elements to insert. + A new immutable list that includes the specified elements. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to match . + Returns . + + + Removes the first occurrence of a specified object from this immutable list. + The object to remove from the list. + The equality comparer to use to locate . + A new list with the specified object removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes the specified object from the list. + The objects to remove from the list. + The equality comparer to use to determine if match any objects in the list. + A new immutable list with the specified objects removed, if matched objects in the list. + + + Removes a range of elements from the . + The zero-based starting index of the range of elements to remove. + The number of elements to remove. + A new immutable list with the elements removed. + + + Returns a new list with the first matching element in the list replaced with the specified element. + The element to be replaced. + The element to replace the first occurrence of with + The equality comparer to use for matching . + A new list that contains , even if is the same as . + + does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + A new list that contains the new element, even if the element at the specified location is the same as the new element. + + + Represents an immutable first-in, first-out collection of objects. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Returns a new queue with all the elements removed. + An empty immutable queue. + + + Removes the first element in the immutable queue, and returns the new queue. + The new immutable queue with the first element removed. This value is never null. + The queue is empty. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue with the specified element added. + + + Gets a value that indicates whether this immutable queue is empty. + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Represents a set of elements that can only be modified by creating a new instance of the set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored in the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable set contains a specified element. + The element to locate in the set. + + if the set contains the specified value; otherwise, . + + + Removes the elements in the specified collection from the current immutable set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains only elements that exist in this set and the specified set. + The collection to compare to the current . + A new immutable set that contains elements that exist in both sets. + + + Determines whether the current immutable set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a proper (strict) superset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, false. + + + Determines whether the current immutable set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Determines whether the current immutable set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Determines whether the set contains a specified value. + The value to search for. + The matching value from the set, if found, or equalvalue if there are no matches. + + if a matching value was found; otherwise, . + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Represents an immutable last-in-first-out (LIFO) collection. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets a value that indicates whether this immutable stack is empty. + + if this stack is empty; otherwise,. + + + Returns the element at the top of the immutable stack without removing it. + The element at the top of the stack. + The stack is empty. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never null + The stack is empty. + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + Provides methods for creating an array that is immutable; meaning it cannot be changed once it is created. +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Searches the sorted immutable array for a specified element using the default comparer and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The object to search for. + The comparer implementation to use when comparing elements, or null to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element, if it's found. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . + + is less than the lower bound of . +-or- + is less than zero. + + + Searches a sorted immutable array for a specified element and returns the zero-based index of the element. + The sorted array to search. + The starting index of the range to search. + The length of the range to search. + The object to search for. + The comparer to use when comparing elements for equality or to use the default comparer. + The type of element stored in the array. + The zero-based index of the item in the array, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . + + is null and does not implement or the search encounters an element that does not implement . + + and do not specify a valid range in . +-or- + is , and is of a type that is not compatible with the elements of . + + is less than the lower bound of . +-or- + is less than zero. + + + Creates an empty immutable array. + The type of elements stored in the array. + An empty immutable array. + + + Creates an immutable array that contains the specified object. + The object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified object. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array that contains the specified objects. + The first object to store in the array. + The second object to store in the array. + The third object to store in the array. + The fourth object to store in the array. + The type of elements stored in the array. + An immutable array that contains the specified objects. + + + Creates an immutable array from the specified array of objects. + The array of objects to populate the array with. + The type of elements stored in the array. + An immutable array that contains the array of items. + + + Creates an immutable array with specified objects from another array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates an immutable array with the specified objects from another immutable array. + The source array of objects. + The index of the first element to copy from . + The number of elements from to include in this immutable array. + The type of elements stored in the array. + An immutable array that contains the specified objects from the source array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a mutable array that can be converted to an without allocating new memory. + The initial capacity of the builder. + The type of elements stored in the builder. + A mutable array of the specified type that can be efficiently converted to an immutable array. + + + Creates a new populated with the specified items. + The elements to add to the array. + The type of element stored in the array. + An immutable array that contains the specified items. + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The function to apply to each element from the source array. + An argument to be passed to the selector mapping function. + + + + + + Initializes a new instance of the struct. + The source array to initialize the resulting array with. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + The function to apply to each element from the source array included in the resulting array. + An argument to be passed to the selector mapping function. + + + + + + Creates an immutable array from the specified collection. + The collection of objects to copy to the immutable array. + The type of elements contained in . + An immutable array that contains the specified collection of objects. + + + Creates an immutable array from the current contents of the builder's array. + The builder to create the immutable array from. + The type of elements contained in the immutable array. + An immutable array that contains the current contents of the builder's array. + + + Represents an array that is immutable; meaning it cannot be changed once it is created. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element stored by the array. + + + Returns a copy of the original array with the specified item added to the end. + The item to be added to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the array. + A new array with the elements added. + + + Returns a new immutable array that contains the elements of this array cast to a different type. + The type of array element to return. + An immutable array that contains the elements of this array, cast to a different type. If the cast fails, returns an array whose property returns . + + + Creates a new read-only memory region over this immutable array. + The read-only memory representation of this immutable array. + + + Creates a new read-only span over this immutable array. + The read-only span representation of this immutable array. + + + A writable array accessor that can be converted into an instance without allocating extra memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the array. + The object to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items to the end of the array. + The items to add to the array. + The number of elements from the source array to add. + + + Adds the specified items to the end of the array. + The items to add to the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Adds the specified items that derive from the type currently in the array, to the end of the array. + The items to add to the end of the array. + The type that derives from the type of item already in the array. + + + Gets or sets the length of the internal array. When set, the internal array is reallocated to the given capacity if it is not already the specified length. + The length of the internal array. + + + Removes all items from the array. + + + Determines whether the array contains a specific value. + The object to locate in the array. + + if the object is found; otherwise, . + + + Copies the current contents to the specified array. + The array to copy to. + The index to start the copy operation. + + + Gets or sets the number of items in the array. + The number of items in the array. + + + Gets an object that can be used to iterate through the collection. + An object that can be used to iterate through the collection. + + + Determines the index of a specific item in the array. + The item to locate in the array. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index of the specified item. + The item to locate in the array. + The starting position of the search. + The number of elements to search. + The index of if it's found in the list; otherwise, -1. + + + Determines the index for the specified item. + The item to locate in the array. + The index at which to begin the search. + The starting position of the search. + The equality comparer to use in the search + The index of if it's found in the list; otherwise, -1. + + + Inserts an item in the array at the specified index. + The zero-based index at which to insert the item. + The object to insert into the array. + + + Gets or sets the item at the specified index. + The index of the item to get or set. + The item at the specified index. + The specified index is not in the array. + + + Gets a read-only reference to the element at the specified index. + The item index. + The read-only reference to the element at the specified index. + + is greater or equal to the array count. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The 0-based index where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Determines the 0-based index of the last occurrence of the specified item in this array. + The item to search for. + The starting position of the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Extracts the internal array as an and replaces it with a zero length array. + When doesn't equal . + + + Removes the specified element. + The item to remove. + + if was found and removed; otherwise, . + + + Removes the item at the specified index from the array. + The zero-based index of the item to remove. + + + Reverses the order of elements in the collection. + + + Sorts the contents of the array. + + + Sorts the contents of the array. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Sorts the elements in the entire array using the specified . + The to use when comparing elements. + + is null. + + + Sorts the contents of the array. + The starting index for the sort. + The number of elements to include in the sort. + The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used. + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Returns an enumerator that iterates through the array. + An enumerator that iterates through the array. + + + Creates a new array with the current contents of this . + A new array with the contents of this . + + + Returns an immutable array that contains the current contents of this . + An immutable array that contains the current contents of this . + + + Initializes a new instance of the struct by casting the underlying array to an array of type . + + Thrown if the cast is illegal. + + + Initializes a new instance of the struct based on the contents of an existing instance, allowing a covariant static cast to efficiently reuse the existing array. + The array to initialize the array with. No copy is made. + + + + Returns an array with all the elements removed. + An array with all of the elements removed. + + + Determines whether the specified item exists in the array. + The item to search for. + + if the specified item was found in the array; otherwise . + + + Copies the contents of this array to the specified array. + The array to copy to. + + + Copies the contents of this array to the specified array starting at the specified destination index. + The array to copy to. + The index in where copying begins. + + + Copies the specified items in this array to the specified array at the specified starting index. + The index of this array where copying begins. + The array to copy to. + The index in where copying begins. + The number of elements to copy from this array. + + + Gets an empty immutable array. + + + An array enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the current item. + The current item. + + + Advances to the next value in the array. + + if another item exists in the array; otherwise, . + + + Indicates whether specified array is equal to this array. + An object to compare with this object. + + if is equal to this array; otherwise, . + + + Determines if this array is equal to the specified object. + The to compare with this array. + + if this array is equal to ; otherwise, . + + + Returns an enumerator that iterates through the contents of the array. + An enumerator. + + + Returns a hash code for this instance. + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + Searches the array for the specified item. + The item to search for. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Searches the array for the specified item. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The zero-based index position of the item if it is found, or -1 if it is not. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the item inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Inserts the specified values at the specified index. + The index at which to insert the value. + The elements to insert. + A new immutable array with the items inserted at the specified index. + + + Gets a value indicating whether this array was declared but not initialized. + + if the is ; otherwise, . + + + Gets a value indicating whether this is empty or is not initialized. + + if the is or ; otherwise, . + + + Gets a value indicating whether this is empty. + + if the is empty; otherwise, . + + + Gets the element at the specified index in the immutable array. + The zero-based index of the element to get. + The element at the specified index in the immutable array. + + + Gets a read-only reference to the element at the specified in the read-only list. + The zero-based index of the element to get a reference to. + A read-only reference to the element at the specified in the read-only list. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Searches the array for the specified item; starting at the end of the array. + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + Gets the number of elements in the array. + The number of elements in the array + + + Filters the elements of this array to those assignable to the specified type. + The type to filter the elements of the sequence on. + An that contains elements from the input sequence of type of . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates if two arrays are equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are equal; otherwise, . + + + Returns a value that indicates whether two arrays are not equal. + The array to the left of the operator. + The array to the right of the operator. + + if the arrays are not equal; otherwise, . + + + Checks for inequality between two array. + The object to the left of the operator. + The object to the right of the operator. + + if the two arrays are not equal; otherwise, . + + + Returns an array with the first occurrence of the specified element removed from the array. If no match is found, the current array is returned. + The item to remove. + A new array with the item removed. + + + Returns an array with the first occurrence of the specified element removed from the array. + If no match is found, the current array is returned. + The item to remove. + The equality comparer to use in the search. + A new array with the specified item removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the item at the specified index removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + A new array with the elements removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + A new list with the elements removed. + + + Removes the specified items from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The item to add to the list. + The new array that contains at the specified index. + + + Sorts the elements in the immutable array using the default comparer. + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the immutable array using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Sorts the elements in the entire using the specified . + The to use when comparing elements. + The sorted list. + + is null. + + + Sorts the specified elements in the immutable array using the specified comparer. + The index of the first element to sort. + The number of elements to include in the sort. + The implementation to use when comparing elements, or to use the default comparer + A new immutable array that contains the items in this array, in sorted order. + + + Throws in all cases. + The item to add to the end of the array. + + + Throws in all cases. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Throws in all cases. + The object to remove from the array. + Throws in all cases. + + + Returns an enumerator that iterates through the array. + An enumerator that can be used to iterate through the array. + + + Throws in all cases. + The index of the location to insert the item. + The item to insert. + + + Gets or sets the element at the specified index in the read-only list. + The zero-based index of the element to get. + The element at the specified index in the read-only list. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The index. + + + Gets the number of array in the collection. + Thrown if the property returns true. + + + Gets the element at the specified index. + The index. + The element. + Thrown if the property returns true. + + + Copies this array to another array starting at the specified index. + The array to copy this array to. + The index in the destination array to start the copy operation. + + + Gets the size of the array. + Thrown if the property returns true. + + + See the interface. + + + Gets the sync root. + + + Returns an enumerator that iterates through the immutable array. + An enumerator that iterates through the immutable array. + The property returns . + + + Throws in all cases. + The value to add to the array. + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + Thrown in all cases. + + + Throws in all cases. + The value to check for. + Throws in all cases. + + + Gets the value at the specified index. + The value to return the index of. + The value of the element at the specified index. + + + Throws in all cases. + Index that indicates where to insert the item. + The value to insert. + Thrown in all cases. + + + Gets a value indicating whether this instance is fixed size. + + true if this instance is fixed size; otherwise, false. + + + Gets a value indicating whether this instance is read only. + + true if this instance is read only; otherwise, false. + + + Gets or sets the at the specified index. + The index. + Always thrown from the setter. + Thrown if the property returns true. + + + Throws in all cases. + The value to remove from the array. + Thrown in all cases. + + + Throws in all cases. + The index of the item to remove. + Thrown in all cases. + + + Returns a copy of the original array with the specified item added to the end. + The value to add to the end of the array. + A new array with the specified item added to the end. + + + Returns a copy of the original array with the specified elements added to the end of the array. + The elements to add to the end of the array. + A new array with the elements added to the end. + + + Returns an array with all the elements removed. + An array with all the elements removed. + + + Returns a new array with the specified value inserted at the specified position. + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array with the specified value inserted. + + + Inserts the specified values at the specified index + The index at which to insert the value. + The elements to insert. + A new array with the specified values inserted. + + + Returns an array with the first occurrence of the specified element removed from the array; if no match is found, the current array is returned. + The value to remove from the array. + The equality comparer to use in the search. + A new array with the value removed. + + + Removes all the items from the array that meet the specified condition. + The delegate that defines the conditions of the elements to remove. + A new array with items that meet the specified condition removed. + + + Returns an array with the element at the specified position removed. + The 0-based index of the element to remove from the returned array. + A new array with the specified item removed. + + + Removes the specified items from this array. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new array with the elements removed. + + + Returns an array with the elements at the specified position removed. + The 0-based index of the starting element to remove from the array. + The number of elements to remove from the array. + The new array with the specified elements removed. + + + Finds the first element in the array equal to the specified value and replaces the value with the specified new value. + The value to find and replace in the array. + The value to replace the oldvalue with. + The equality comparer to use to compare values. + A new array that contains even if the new and old values are the same. + + is not found in the array. + + + Replaces the item at the specified index with the specified item. + The index of the item to replace. + The value to add to the list. + The new array that contains at the specified index. + + + Determines whether the current collection element precedes, occurs in the same position as, or follows another element in the sort order. + The element to compare with the current instance. + The object used to compare members of the current array with the corresponding members of other array. + An integer that indicates whether the current element precedes, is in the same position or follows the other element. + The arrays are not the same length. + + + Determines whether this array is structurally equal to the specified array. + The array to compare with the current instance. + An object that determines whether the current instance and other are structurally equal. + + if the two arrays are structurally equal; otherwise, . + + + Returns a hash code for the current instance. + An object that computes the hash code of the current object. + The hash code for the current instance. + + + Creates a mutable array that has the same contents as this array and can be efficiently mutated across multiple operations using standard mutable interfaces. + The new builder with the same contents as this array. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Determines whether the specified immutable dictionary contains the specified key/value pair. + The immutable dictionary to search. + The key to locate in the immutable dictionary. + The value to locate on the specified key, if the key is found. + The type of the keys in the immutable dictionary. + The type of the values in the immutable dictionary. + + if this map contains the specified key/value pair; otherwise, . + + + Creates an empty immutable dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates an empty immutable dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable dictionary. + + + Creates a new immutable dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + Creates a new immutable dictionary that contains the specified items. + The items used to populate the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Creates a new immutable dictionary that contains the specified items and uses the specified key comparer. + The comparer implementation to use to compare keys for equality. + The comparer implementation to use to compare values for equality. + The items to add to the dictionary before it's immutable. + The type of keys in the dictionary. + The type of values in the dictionary. + A new immutable dictionary that contains the specified items and uses the specified comparer. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The type of the key. + The type of the value. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The dictionary to retrieve the value from. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The type of the key. + The type of the value. + The value for the key, or if no matching key was found. + + + Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Constructs an immutable dictionary based on some transformation of a sequence. + The source collection used to generate the immutable dictionary. + The function used to transform keys for the immutable dictionary. + The key comparer to use for the dictionary. + The type of element in the source collection. + The type of key in the resulting immutable dictionary. + The immutable dictionary that contains elements from , with keys transformed by applying . + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable dictionary from the current contents of the builder's dictionary. + The builder to create the immutable dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Represents an immutable, unordered collection of keys and values. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the keys in the dictionary. + The type of the values in the dictionary. + + + Adds an element with the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + A new immutable dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specified key/value pairs to the immutable dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a hash map that mutates with little or no memory allocations and that can produce or build on immutable hash map instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable dictionary. + The key of the element to add. + The value of the element to add. + + is null. + An element with the same key already exists in the dictionary. + The dictionary is read-only. + + + Adds the specified item to the immutable dictionary. + The object to add to the dictionary. + The dictionary is read-only. + + + Adds a sequence of values to this collection. + The items to add to this collection. + + + Removes all items from the immutable dictionary. + The dictionary is read-only. + + + Determines whether the immutable dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element that has the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + is null. + + + Determines whether the immutable dictionary contains an element that has the specified value. + The value to locate in the immutable dictionary. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements contained in the immutable dictionary. + The number of elements contained in the immutable dictionary. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the collection. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the element with the specified key. + The element to get or set. + The element that has the specified key. + + is . + The property is being retrieved, and is not found. + The property is being set, and the is read-only. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a collection that contains the keys of the immutable dictionary. + A collection that contains the keys of the object that implements the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the dictionary. + + is null. + The dictionary is read-only. + + + Removes the first occurrence of a specific object from the immutable dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns false if is not found in the dictionary. + The dictionary is read-only. + + + Removes any entries with keys that match those found in the specified sequence from the immutable dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array of type , starting at the specified array index. + The one-dimensional array of type that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable dictionary based on the contents of this instance. + An immutable dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Returns the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, returns the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the immutable dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets or sets the value comparer. + The value comparer. + + + Gets a collection that contains the values of the immutable dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified key. + The key to locate. + + if the immutable dictionary contains an element with the specified key; otherwise, . + + + Determines whether the immutable dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable dictionary + + + Enumerates the contents of the immutable dictionary without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element in the dictionary at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the dictionary. + The dictionary was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the dictionary. + The dictionary was modified after the enumerator was created. + + + Gets the current element. + + + Returns an enumerator that iterates through the immutable dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The type of the key. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable dictionary. + The key comparer. + + + Gets the keys in the immutable dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified key from the immutable dictionary. + The key of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified key cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable dictionary, possibly overwriting an existing value for the key. + The key of the entry to add. + The key value to set. + A new immutable dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + A new immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the immutable dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + is null. + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Gets the values in the immutable dictionary. + The values in the immutable dictionary. + + + Gets an instance of the immutable dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable hash set. + The type of items to be stored in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the specified array of items. + An array that contains the items to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates an empty immutable hash set that uses the specified equality comparer. + The object to use for comparing objects in the set for equality. + The type of items in the immutable hash set. + An empty immutable hash set. + + + Creates a new immutable hash set that contains the specified item and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The item to prepopulate the hash set with. + The type of items in the immutable hash set. + A new immutable hash set that contains the specified item. + + + Creates a new immutable hash set that contains the items in the specified collection and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + An array that contains the items to prepopulate the hash set with. + The type of items stored in the immutable hash set. + A new immutable hash set that contains the specified items. + + + Creates a new immutable hash set builder. + The type of items stored by the collection. + The immutable hash set builder. + + + Creates a new immutable hash set builder. + The object to use for comparing objects in the set for equality. + The type of items stored by the collection. + The new immutable hash set builder. + + + Creates a new immutable hash set prefilled with the specified items. + The items to add to the hash set. + The type of items stored by the collection. + The new immutable hash set that contains the specified items. + + + Creates a new immutable hash set that contains the specified items and uses the specified equality comparer for the set type. + The object to use for comparing objects in the set for equality. + The items add to the collection before immutability is applied. + The type of items stored in the collection. + The new immutable hash set. + + + Enumerates a sequence and produces an immutable hash set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type. + The sequence to enumerate. + The object to use for comparing objects in the set for equality. + The type of the elements in the sequence. + An immutable hash set that contains the items in the specified sequence and uses the specified equality comparer. + + + Creates an immutable hash set from the current contents of the builder's set. + The builder to create the immutable hash set from. + The type of the elements in the hash set. + An immutable hash set that contains the current contents in the builder's set. + + + Represents an immutable, unordered hash set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the hash set. + + + Adds the specified element to the hash set. + The element to add to the set. + A hash set that contains the added value and any values previously held by the object. + + + Represents a hash set that mutates with little or no memory allocations and that can produce or build on immutable hash set instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds the specified item to the immutable hash set. + The item to add. + + if the item did not already belong to the collection; otherwise, . + + + Removes all items from the immutable hash set. + The hash set is read-only. + + + Determines whether the immutable hash set contains a specific value. + The object to locate in the hash set. + + if is found in the hash set ; otherwise, . + + + Gets the number of elements contained in the immutable hash set. + The number of elements contained in the immutable hash set. + + + Removes all elements in the specified collection from the current hash set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the immutable hash set. + An enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets or sets the key comparer. + The key comparer. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of a specific object from the immutable hash set. + The object to remove from the set. + + if was successfully removed from the set ; otherwise, . This method also returns if is not found in the original set. + The set is read-only. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an item to the hash set. + The object to add to the set. + The set is read-only. + + + Copies the elements of the hash set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the hash set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current set. + + + Retrieves an empty immutable hash set that has the same sorting and ordering semantics as this instance. + An empty hash set that has the same sorting and ordering semantics as this instance. + + + Determines whether this immutable hash set contains the specified element. + The object to locate in the immutable hash set. + + if is found in the ; otherwise, . + + + Gets the number of elements in the immutable hash set. + The number of elements in the hash set. + + + Gets an immutable hash set for this type that uses the default . + + + Enumerates the contents of the immutable hash set without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable hash set. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the hash set. + The hash set was modified after the enumerator was created. + + + Sets the enumerator to its initial position, which is before the first element in the hash set. + The hash set was modified after the enumerator was created. + + + Gets the current element. + + + Removes the elements in the specified collection from the current immutable hash set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Creates an immutable hash set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Gets a value that indicates whether the current immutable hash set is empty. + + if this instance is empty; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of the specified collection; otherwise, . + + + Determines whether the current immutable hash set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of the specified collection; otherwise, . + + + Gets the object that is used to obtain hash codes for the keys and to check the equality of values in the immutable hash set. + The comparer used to obtain hash codes for the keys and check equality. + + + Determines whether the current immutable hash set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and the specified collection share at least one common element; otherwise, . + + + Removes the specified element from this immutable hash set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Determines whether the current immutable hash set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable hash set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Adds an item to the set. + The object to add to the set. + The set is read-only. + + + Removes all items from this set. + The set is read-only. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + + if the element is successfully removed; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that iterates through the collection. + + + Adds an element to the current set and returns a value that indicates whether the element was successfully added. + The element to add to the collection. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current collection. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or in the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a set. + An enumerator that can be used to iterate through the set. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting or ordering semantics as this instance. + + + Removes the elements in the specified collection from the current set. + The collection of items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates an immutable hash set that has the same contents as this set and can be efficiently mutated across multiple operations by using standard mutable interfaces. + A set with the same contents as this set that can be efficiently mutated across multiple operations by using standard mutable interfaces. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Creates a new immutable hash set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable hash set with the items added; or the original set if all the items were already in the set. + + + Gets an instance of the immutable hash set that uses the specified equality comparer for its search methods. + The equality comparer to use. + An instance of this immutable hash set that uses the given comparer. + + + Contains interlocked exchange mechanisms for immutable collections. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The value to use if no previous value exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Obtains the value from a dictionary after having added it or updated an existing entry. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The function that receives the key and returns a new value to add to the dictionary when no value previously exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The added or updated value. + + + Atomically enqueues an element to the end of a queue. + The variable or field to atomically update. + The value to enqueue. + The type of items contained in the collection + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified key is not in the dictionary. + The key for the value to get or add. + The value to add to the dictionary the key is not found. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. This delegate will not be invoked more than once. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The value at the specified key or if the key was not present. + + + Gets the value for the specified key from the dictionary, or if the key was not found, adds a new value to the dictionary. + The variable or field to update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. + The argument to pass to the value factory. + The type of the keys contained in the collection. + The type of the values contained in the collection. + The type of the argument supplied to the value factory. + The value at the specified key or if the key was not present. + + + Compares two immutable arrays for equality and, if they are equal, replaces one of the arrays. + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The type of element stored by the array. + The original value in . + + + Sets an array to the specified array and returns a reference to the original array, as an atomic operation. + The array to set to the specified value. + The value to which the parameter is set. + The type of element stored by the array. + The original value of . + + + Sets an array to the specified array if the array has not been initialized. + The array to set to the specified value. + The value to which the parameter is set, if it's not initialized. + The type of element stored by the array. + + if the array was assigned the specified value; otherwise, . + + + Pushes a new element onto the stack. + The stack to update. + The value to push on the stack. + The type of items in the stack. + + + Adds the specified key and value to the dictionary if the key is not in the dictionary. + The dictionary to update with the specified key and value. + The key to add, if is not already defined in the dictionary. + The value to add. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key is not in the dictionary; otherwise, . + + + Atomically removes and returns the specified element at the head of the queue, if the queue is not empty. + The variable or field to atomically update. + Set to the value from the head of the queue, if the queue not empty. + The type of items in the queue. + + if the queue is not empty and the head element is removed; otherwise, . + + + Removes an element from the top of the stack, if there is an element to remove. + The stack to update. + Receives the value removed from the stack, if the stack is not empty. + The type of items in the stack. + + if an element is removed from the stack; otherwise, . + + + Removes the element with the specified key, if the key exists. + The dictionary to update. + The key to remove. + Receives the value of the removed item, if the dictionary is not empty. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if the key was found and removed; otherwise, . + + + Sets the specified key to the specified value if the specified key already is set to a specific value. + The dictionary to update. + The key to update. + The new value to set. + The current value for in order for the update to succeed. + The type of the keys contained in the collection. + The type of the values contained in the collection. + + if and are present in the dictionary and comparison was updated to ; otherwise, . + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The type of data. + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race. + The variable or field to be changed, which may be accessed by multiple threads. + A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. + The argument to pass to . + The type of data. + The type of argument passed to the . + + if the location's value is changed by applying the result of the function; if the location's value remained the same because the last invocation of returned the existing value. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable list. + The type of items to be stored in the . + An empty immutable list. + + + Creates a new immutable list that contains the specified item. + The item to prepopulate the list with. + The type of items in the . + A new that contains the specified item. + + + Creates a new immutable list that contains the specified array of items. + An array that contains the items to prepopulate the list with. + The type of items in the . + A new immutable list that contains the specified items. + + + Creates a new immutable list builder. + The type of items stored by the collection. + The immutable collection builder. + + + Creates a new immutable list that contains the specified items. + The items to add to the list. + The type of items in the . + An immutable list that contains the specified items. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the first occurrence of item within the range of elements in the Immutable list that extends from index to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The equality comparer to use in the search. + The type of items in the list. + The zero-based index of the last occurrence of item within the entire the Immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The list to search. + The object to locate in the Immutable list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The type of items in the list. + The zero-based index of the last occurrence of item within the range of elements in the Immutable list that extends from the first element to index, if found; otherwise, -1. + + + Removes the specified value from this list. + The list to search. + The value to remove. + The type of items in the list. + A new immutable list with the element removed, or this list if the element is not in this list. + + + Removes the specified values from this list. + The list to search. + The items to remove if matches are found in this list. + The type of items in the list. + A new immutable list with the elements removed. + + + Replaces the first equal element in the list with the specified element. + The list to search. + The element to replace. + The element to replace the old element with. + The type of items in the list. + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + Enumerates a sequence and produces an immutable list of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable list that contains the items in the specified sequence. + + + Creates an immutable list from the current contents of the builder's collection. + The builder to create the immutable list from. + The type of the elements in the list. + An immutable list that contains the current contents in the builder's collection. + + + Represents an immutable list, which is a strongly typed list of objects that can be accessed by index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the list. + + + Adds the specified object to the end of the immutable list. + The object to add. + A new immutable list with the object added. + + + Adds the elements of the specified collection to the end of the immutable list. + The collection whose elements will be added to the end of the list. + A new immutable list with the elements added. + + + Searches the entire sorted list for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be for reference types. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + The default comparer cannot find a comparer implementation of the for type T. + + + Searches the entire sorted list for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements or null to use the default comparer. + The zero-based index of item in the sorted List, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + comparer is , and the default comparer cannot find an comparer implementation for type T. + + + Searches a range of elements in the sorted list for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. The value can be null for reference types. + The comparer implementation to use when comparing elements, or to use the default comparer. + The zero-based index of item in the sorted list, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of . + index is less than 0 or is less than 0. + index and do not denote a valid range in the list. + + is , and the default comparer cannot find an comparer implementation for type T. + + + Represents a list that mutates with little or no memory allocations and that can produce or build on immutable list instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an item to the immutable list. + The item to add to the list. + + + Adds a series of elements to the end of this list. + The elements to add to the end of the list. + + + Searches the entire for an element using the default comparer and returns the zero-based index of the element. + The object to locate. The value can be null for reference types. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + The default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the entire for an element using the specified comparer and returns the zero-based index of the element. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Searches the specified range of the for an element using the specified comparer and returns the zero-based index of the element. + The zero-based starting index of the range to search. + The length of the range to search. + The object to locate. This value can be null for reference types. + The implementation to use when comparing elements, or for the default comparer. + The zero-based index of item in the , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than . + + is less than 0. +-or- + is less than 0. + + and do not denote a valid range in the . + + is , and the default comparer cannot find an implementation of the generic interface or the interface for type T. + + + Removes all items from the immutable list. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if item is found in the list; otherwise, . + + + Creates a new immutable list from the list represented by this builder by using the converter function. + The converter function. + The type of the output of the delegate converter function. + A new immutable list from the list represented by this builder. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + The number of elements to copy. + + + Gets the number of elements in this immutable list. + The number of elements in this list. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, -1. + + + Performs the specified action on each element of the list. + The delegate to perform on each element of the list. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the first occurrence of within the range of elements in the immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that extends from to the last element, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Inserts an item to the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the immutable list. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which the new elements should be inserted. + The collection whose elements should be inserted into the immutable list. The collection itself cannot be , but it can contain elements that are null, if type T is a reference type. + + + Gets or sets the value for a given index in the list. + The index of the item to get or set. + The value at the specified index. + + + Gets a read-only reference to the value for a given into the list. + The index of the desired element. + A read-only reference to the value at the specified . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be for reference types. + The zero-based index of the last occurrence of within the entire immutable list, if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that extends from the first element to , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The zero-based index of the last occurrence of within the range of elements in the immutable list that contains number of elements and ends at , if found; otherwise, -1. + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The object to locate in the immutable list. The value can be for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements to search. + The value comparer to use for comparing elements for equality. + The zero-based index of the first occurrence of item within the range of elements in the immutable list that starts at and contains number of elements, if found; otherwise, -1 + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + + if item was successfully removed from the list; otherwise, . This method also returns if item is not found in the list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The number of elements removed from the immutable list. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove from the list. + + + Reverses the order of the elements in the entire immutable list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + + + Sorts the elements in the entire immutable list by using the default comparer. + + + Sorts the elements in the entire immutable list by using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + + + Sorts the elements in the entire immutable list by using the specified comparison object. + The object to use when comparing elements. + + is . + + + Sorts the elements in a range of elements in the immutable list by using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Copies the elements of the list to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Adds an item to the list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + + + + Removes all items from the list. + + + + Determines whether the list contains a specific value. + The object to locate in the list. + + if the is found in the list; otherwise, . + + + + Determines the index of a specific item in the list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item to the list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + + + Removes the first occurrence of a specific object from the list. + The object to remove from the list. + + + + Creates an immutable list based on the contents of this instance. + An immutable list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Removes all elements from the immutable list. + An empty list that retains the same sort or unordered semantics that this instance has. + + + Determines whether this immutable list contains the specified value. + The value to locate. + + if the list contains the specified value; otherwise, . + + + Converts the elements in the current immutable list to another type, and returns a list containing the converted elements. + A delegate that converts each element from one type to another type. + The type of the elements of the target array. + A list of the target type containing the converted elements from the current . + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the beginning of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Copies a range of elements from the immutable list to a compatible one-dimensional array, starting at the specified index of the target array. + The zero-based index in the source immutable list at which copying begins. + The one-dimensional array that is the destination of the elements copied from the immutable list. The array must have zero-based indexing. + The zero-based index in array at which copying begins. + The number of elements to copy. + + + Gets the number of elements contained in the list. + The number of elements in the list. + + + Gets an empty set with the default sort comparer. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances enumeration to the next element of the immutable list. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the list. + + + Sets the enumerator to its initial position, which is before the first element in the immutable list. + + + The current element. + + + Determines whether the immutable list contains elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + + if the immutable list contains one or more elements that match the conditions defined by the specified predicate; otherwise, . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Retrieves all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to search for. + An immutable list that contains all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty immutable list. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that starts at the specified index and contains the specified number of elements. + The zero-based starting index of the search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the immutable list that extends from the specified index to the last element. + The zero-based starting index of the search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type . + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that contains the specified number of elements and ends at the specified index. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the immutable list that extends from the first element to the specified index. + The zero-based starting index of the backward search. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire immutable list. + The delegate that defines the conditions of the element to search for. + The zero-based index of the last occurrence of an element that matches the conditions defined by , if found; otherwise, ?1. + + + Performs the specified action on each element of the immutable list. + The delegate to perform on each element of the immutable list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the immutable list. + + + Creates a shallow copy of a range of elements in the source immutable list. + The zero-based index at which the range starts. + The number of elements in the range. + A shallow copy of a range of elements in the source immutable list. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the entire immutable list. + The object to locate in the immutable list. The value can be null for reference types. + The zero-based index of the first occurrence of within the entire immutable list, if found; otherwise, ?1. + + + Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the list that starts at the specified index and contains the specified number of elements. + The object to locate in the list The value can be null for reference types. + The zero-based starting index of the search. 0 (zero) is valid in an empty list. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the first occurrence of item within the range of elements in the list that starts at index and contains count number of elements, if found; otherwise, -1. + + + Inserts the specified object into the immutable list at the specified index. + The zero-based index at which to insert the object. + The object to insert. + The new immutable list after the object is inserted. + + + Inserts the elements of a collection into the immutable list at the specified index. + The zero-based index at which to insert the elements. + The collection whose elements should be inserted. + The new immutable list after the elements are inserted. + + + Gets a value that indicates whether this list is empty. + + if the list is empty; otherwise, . + + + Gets the element at the specified index of the list. + The index of the element to retrieve. + The element at the specified index. + In a get operation, is negative or not less than . + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + is negative or not less than . + + + Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the list that contains the specified number of elements and ends at the specified index. + The object to locate in the list. The value can be null for reference types. + The zero-based starting index of the backward search. + The number of elements in the section to search. + The equality comparer to use in the search. + The zero-based index of the last occurrence of item within the range of elements in the list that contains count number of elements and ends at index, if found; otherwise, -1. + + + Removes the first occurrence of the specified object from this immutable list. + The object to remove. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes the first occurrence of the object that matches the specified value from this immutable list. + The value of the element to remove from the list. + The equality comparer to use in the search. + A new list with the object removed, or this list if the specified object is not in this list. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + The new list with the elements removed. + + + Removes the element at the specified index. + The zero-based index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list. + The collection whose elements should be removed if matches are found in this list. + A new list with the elements removed. + + + Removes the specified values from this list. + The items to remove if matches are found in this list. + The equality comparer to use in the search. + A new list with the elements removed. + + + Removes a range of elements, starting from the specified index and containing the specified number of elements, from this immutable list. + The starting index to begin removal. + The number of elements to remove. + A new list with the elements removed. + + + Replaces the specified element in the immutable list with a new element. + The element to replace. + The element to replace with. + The new list with the replaced element, even if it is equal to the old element. + + does not exist in the immutable list. + + + Replaces the specified element in the immutable list with a new element. + The element to replace in the list. + The element to replace with. + The comparer to use to check for equality. + A new list with the object replaced, or this list if the specified object is not in this list. + + + Reverses the order of the elements in the entire immutable list. + The reversed list. + + + Reverses the order of the elements in the specified range of the immutable list. + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + The reversed list. + + + Replaces an element at a given position in the immutable list with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list with the replaced element, even if it is equal to the old element at that position. + + + Sorts the elements in the entire immutable list using the default comparer. + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Sorts the elements in the entire immutable list using the specified comparer. + The delegate to use when comparing elements. + The sorted list. + + is . + + + Sorts a range of elements in the immutable list using the specified comparer. + The zero-based starting index of the range to sort. + The length of the range to sort. + The implementation to use when comparing elements, or to use the default comparer (). + The sorted list. + + + Adds the specified item to the immutable list. + The item to add. + + + + Removes all items from the immutable list. + + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove. + + if was successfully removed from the list; otherwise, . This method also returns if is not found in the original list. + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Inserts an object in the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert. + + + + Gets or sets the value at the specified index. + + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the value at the specified index. + The zero-based index of the item to remove. + + + + Copies the entire immutable list to a compatible one-dimensional array, starting at the specified array index. + The one-dimensional array that is the destination of the elements copied from immutable list. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through the immutable list. + An enumerator that can be used to iterate through the list. + + + Adds an item to the immutable list. + The object to add to the list. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the list. + Always thrown. + + + Removes all items from the immutable list. + Always thrown. + + + Determines whether the immutable list contains a specific value. + The object to locate in the list. + + if the object is found in the list; otherwise, . + + + + Determines the index of a specific item in the immutable list. + The object to locate in the list. + The index of if found in the list; otherwise, -1. + + + + Inserts an item into the immutable list at the specified index. + The zero-based index at which should be inserted. + The object to insert into the list. + Always thrown. + + + Gets a value indicating whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The value at the specified index. + Thrown from getter when is negative or not less than . + Always thrown from the setter. + + + Removes the first occurrence of a specific object from the immutable list. + The object to remove from the list. + Always thrown. + + + Removes the item at the specified index of the immutable list. + The zero-based index of the item to remove. + Always thrown. + + + Adds the specified value to this immutable list. + The value to add. + A new list with the element added. + + + Adds the specified values to this immutable list. + The values to add. + A new list with the elements added. + + + Retrieves an empty list that has the same sorting and ordering semantics as this instance. + An empty list that has the same sorting and ordering semantics as this instance. + + + Inserts the specified element at the specified index in the immutable list. + The index at which to insert the value. + The element to insert. + A new immutable list that includes the specified element. + + + Inserts the specified elements at the specified index in the immutable list. + The index at which to insert the elements. + The elements to insert. + A new immutable list that includes the specified elements. + + + Removes the element with the specified value from the list. + The value of the element to remove from the list. + The comparer to use to compare elements for equality. + A new with the specified element removed. + + + Removes all the elements that match the conditions defined by the specified predicate. + The delegate that defines the conditions of the elements to remove. + A new immutable list with the elements removed. + + + Removes the element at the specified index of the immutable list. + The index of the element to remove. + A new list with the element removed. + + + Removes a range of elements from this immutable list that match the items specified. + The range of items to remove from the list, if found. + The equality comparer to use to compare elements. + An immutable list with the items removed. + + or is . + + + Removes the specified number of elements at the specified location from this list. + The starting index of the range of elements to remove. + The number of elements to remove. + A new list with the elements removed. + + + Replaces an element in the list with the specified element. + The element to replace. + The element to replace the old element with. + The equality comparer to use in the search. + The new list. + Thrown when the old value does not exist in the list. + + + Replaces an element in the list at a given position with the specified element. + The position in the list of the element to replace. + The element to replace the old element with. + The new list. + + + Creates a list that has the same contents as this list and can be efficiently mutated across multiple operations using standard mutable interfaces. + The created list with the same contents as this list. + + + Determines whether every element in the immutable list matches the conditions defined by the specified predicate. + The delegate that defines the conditions to check against the elements. + + if every element in the immutable list matches the conditions defined by the specified predicate; otherwise, . If the list has no elements, the return value is . + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable queue. + The type of items to be stored in the immutable queue. + An empty immutable queue. + + + Creates a new immutable queue that contains the specified item. + The item to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified item. + + + Creates a new immutable queue that contains the specified array of items. + An array that contains the items to prepopulate the queue with. + The type of items in the immutable queue. + A new immutable queue that contains the specified items. + + + Creates a new immutable queue that contains the specified items. + The items to add to the queue before immutability is applied. + The type of elements in the queue. + An immutable queue that contains the specified items. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + The queue to remove the item from. + When this method returns, contains the item from the beginning of the queue. + The type of elements in the immutable queue. + The new queue with the item removed. + The stack is empty. + + + Represents an immutable queue. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the queue. + + + Removes all objects from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + The queue is empty. + + + Removes the item at the beginning of the immutable queue, and returns the new queue. + When this method returns, contains the element from the beginning of the queue. + The new immutable queue with the beginning element removed. + The queue is empty. + + + Gets an empty immutable queue. + An empty immutable queue. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Enumerates the contents of an immutable queue without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable queue. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the queue. + + + Returns an enumerator that iterates through the immutable queue. + An enumerator that can be used to iterate through the queue. + + + Gets a value that indicates whether this immutable queue is empty. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if this queue is empty; otherwise, . + + + Returns the element at the beginning of the immutable queue without removing it. + The element at the beginning of the queue. + The queue is empty. + + + Gets a read-only reference to the element at the front of the queue. + The queue is empty. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable queue. + The empty immutable queue. + + + Removes the element at the beginning of the immutable queue, and returns the new queue. + The new immutable queue; never null. + + + Adds an element to the end of the immutable queue, and returns the new queue. + The element to add. + The new immutable queue. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key comparer. + The implementation to use to determine the equality of keys in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates an empty immutable sorted dictionary that uses the specified key and value comparers. + The implementation to use to determine the equality of keys in the dictionary. + The implementation to use to determine the equality of values in the dictionary. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + An empty immutable sorted dictionary. + + + Creates a new immutable sorted dictionary builder. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary builder. + The key comparer. + The value comparer. + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key comparer. + The comparer implementation to use to evaluate keys for equality and sorting. + The items to add to the sorted dictionary. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + The new immutable sorted dictionary that contains the specified items and uses the specified key comparer. + + + Creates a new immutable sorted dictionary from the specified range of items with the specified key and value comparers. + The comparer implementation to use to compare keys for equality and sorting. + The comparer implementation to use to compare values for equality and sorting. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items and uses the specified comparers. + + + Creates an immutable sorted dictionary that contains the specified items and uses the default comparer. + The items to add to the sorted dictionary before it's immutable. + The type of keys stored in the dictionary. + The type of values stored in the dictionary. + An immutable sorted dictionary that contains the specified items. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents. + The sequence of key/value pairs to enumerate. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence of key/value pairs to enumerate. + The key comparer to use when building the immutable dictionary. + The value comparer to use for the immutable dictionary. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the key/value pairs in the specified sequence. + + + Creates an immutable sorted dictionary from the current contents of the builder's dictionary. + The builder to create the immutable sorted dictionary from. + The type of the keys in the dictionary. + The type of the values in the dictionary. + An immutable sorted dictionary that contains the current contents in the builder's dictionary. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable dictionary that contains the items in the specified sequence. + + + Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers. + The sequence to enumerate to generate the dictionary. + The function that will produce the key for the dictionary from each sequence element. + The function that will produce the value for the dictionary from each sequence element. + The key comparer to use for the dictionary. + The value comparer to use for the dictionary. + The type of the elements in the sequence. + The type of the keys in the resulting dictionary. + The type of the values in the resulting dictionary. + An immutable sorted dictionary that contains the items in the specified sequence. + + + Represents an immutable sorted dictionary. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of the key contained in the dictionary. + The type of the value contained in the dictionary. + + + Adds an element with the specified key and value to the immutable sorted dictionary. + The key of the entry to add. + The value of entry to add. + A new immutable sorted dictionary that contains the additional key/value pair. + The given key already exists in the dictionary but has a different value. + + + Adds the specific key/value pairs to the immutable sorted dictionary. + The key/value pairs to add. + A new immutable dictionary that contains the additional key/value pairs. + One of the given keys already exists in the dictionary but has a different value. + + + Represents a sorted dictionary that mutates with little or no memory allocations and that can produce or build on immutable sorted dictionary instances very efficiently. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Adds an element that has the specified key and value to the immutable sorted dictionary. + The key of the element to add. + The value of the element to add. + + + Adds the specified item to the immutable sorted dictionary. + The object to add to the dictionary. + + + Adds a sequence of values to the immutable sorted dictionary. + The items to add to the dictionary. + + + Removes all items from the immutable sorted dictionary. + + + Determines whether the immutable sorted dictionary contains a specific value. + The object to locate in the dictionary. + + if is found in the dictionary; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified key. + The key to locate in the dictionary. + + if the dictionary contains an element with the key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate in the dictionary. The value can be for reference types. + + if the immutable sorted dictionary contains an element with the specified value; otherwise, . + + + Gets the number of elements in this immutable sorted dictionary. + The number of elements in this dictionary. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + Gets the value for a given key if a matching key exists in the dictionary; otherwise the default value. + The key to search for. + The default value to return if no matching key is found in the dictionary. + The value for the key, or if no matching key was found. + + + Gets or sets the value for a specified key in the immutable sorted dictionary. + The key to retrieve the value for. + The value associated with the given key. + + + Gets or sets the key comparer. + The key comparer. + + + Gets a strongly typed, read-only collection of elements. + A strongly typed, read-only collection of elements. + + + Removes the element with the specified key from the immutable sorted dictionary. + The key of the element to remove. + + if the element is successfully removed; otherwise, . This method also returns if was not found in the original dictionary. + + + Removes the first occurrence of a specific object from the immutable sorted dictionary. + The object to remove from the dictionary. + + if was successfully removed from the dictionary; otherwise, . This method also returns if is not found in the dictionary. + + + Removes any entries with keys that match those found in the specified sequence from the immutable sorted dictionary. + The keys for entries to remove from the dictionary. + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The key of the element to add. + The value of the element to add. + + + Determines whether the dictionary object contains an element with the specified key. + The key to locate. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the dictionary. + An object for the dictionary. + + + Gets a value that indicates whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the dictionary. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Creates an immutable sorted dictionary based on the contents of this instance. + An immutable sorted dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. This parameter is passed uninitialized. + + if the object that implements the dictionary contains an element with the specified key; otherwise, . + + + Gets or sets the value comparer. + The value comparer. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets a collection that contains the values of the immutable sorted dictionary. + A collection that contains the values of the object that implements the dictionary. + + + Retrieves an empty immutable sorted dictionary that has the same ordering and key/value comparison rules as this dictionary instance. + An empty dictionary with equivalent ordering and key/value comparison rules. + + + Determines whether this immutable sorted dictionary contains the specified key/value pair. + The key/value pair to locate. + + if the specified key/value pair is found in the dictionary; otherwise, . + + + Determines whether this immutable sorted map contains the specified key. + The key to locate. + + if the immutable dictionary contains the specified key; otherwise, . + + + Determines whether the immutable sorted dictionary contains an element with the specified value. + The value to locate. The value can be for reference types. + + if the dictionary contains an element with the specified value; otherwise, . + + + Gets the number of key/value pairs in the immutable sorted dictionary. + The number of key/value pairs in the dictionary. + + + Gets an empty immutable sorted dictionary. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + + + Advances the enumerator to the next element of the immutable sorted dictionary. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted dictionary. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted dictionary. + + + The current element. + + + Returns an enumerator that iterates through the immutable sorted dictionary. + An enumerator that can be used to iterate through the dictionary. + + + Gets a value that indicates whether this instance of the immutable sorted dictionary is empty. + + if this instance is empty; otherwise, . + + + Gets the associated with the specified key. + The key to retrieve the value for. + The value associated with the specified key. If no results are found, the operation throws an exception. + + + Gets the key comparer for the immutable sorted dictionary. + The key comparer for the dictionary. + + + Gets the keys in the immutable sorted dictionary. + The keys in the immutable dictionary. + + + Removes the element with the specified value from the immutable sorted dictionary. + The value of the element to remove. + A new immutable dictionary with the specified element removed; or this instance if the specified value cannot be found in the dictionary. + + + Removes the elements with the specified keys from the immutable sorted dictionary. + The keys of the elements to remove. + A new immutable dictionary with the specified keys removed; or this instance if the specified keys cannot be found in the dictionary. + + + Sets the specified key and value in the immutable sorted dictionary, possibly overwriting an existing value for the given key. + The key of the entry to add. + The key value to set. + A new immutable sorted dictionary that contains the specified key/value pair. + + + Sets the specified key/value pairs in the immutable sorted dictionary, possibly overwriting existing values for the keys. + The key/value pairs to set in the dictionary. If any of the keys already exist in the dictionary, this method will overwrite their previous values. + An immutable dictionary that contains the specified key/value pairs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Copies the elements of the dictionary to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the dictionary. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value indicating whether access to the is synchronized (thread safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Adds an element with the provided key and value to the dictionary object. + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + Clears this instance. + The dictionary object is read-only. + + + Determines whether the immutable dictionary object contains an element with the specified key. + The key to locate in the dictionary object. + + if the dictionary contains an element with the key; otherwise, . + + + Returns an object for the immutable dictionary object. + An enumerator object for the dictionary object. + + + Gets a value indicating whether the object has a fixed size. + + if the object has a fixed size; otherwise, . + + + Gets a value indicating whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the element with the specified key. + The key. + + + Gets an containing the keys of the . + An containing the keys of the object that implements . + + + Removes the element with the specified key from the immutable dictionary object. + The key of the element to remove. + + + Gets an containing the values in the . + An containing the values in the object that implements . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + + + + + + + + + + + + + + + + + + + + + + Creates an immutable sorted dictionary with the same contents as this dictionary that can be efficiently mutated across multiple operations by using standard mutable interfaces. + A collection with the same contents as this dictionary. + + + Determines whether this dictionary contains a specified key. + The key to search for. + The matching key located in the dictionary if found, or equalkey if no match is found. + + if a match for is found; otherwise, . + + + Gets the value associated with the specified key. + The key whose value will be retrieved. + When this method returns, contains the value associated with the specified key, if the key is found; otherwise, contains the default value for the type of the parameter. + + if the dictionary contains an element with the specified key; otherwise, . + + + Gets the value comparer used to determine whether values are equal. + The value comparer used to determine whether values are equal. + + + Returns a read-only reference to the value associated with the provided . + + The is not present. + + + Gets the values in the immutable sorted dictionary. + The values in the dictionary. + + + Gets an instance of the immutable sorted dictionary that uses the specified key comparer. + The key comparer to use. + An instance of the immutable dictionary that uses the given comparer. + + + Gets an instance of the immutable sorted dictionary that uses the specified key and value comparers. + The key comparer to use. + The value comparer to use. + An instance of the immutable dictionary that uses the given comparers. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable sorted set. + The type of items to be stored in the immutable set. + An empty immutable sorted set. + + + Creates a new immutable sorted set that contains the specified item. + The item to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Creates an empty immutable sorted set that uses the specified comparer. + The implementation to use when comparing items in the set. + The type of items in the immutable set. + An empty immutable set. + + + Creates a new immutable sorted set that contains the specified item and uses the specified comparer. + The implementation to use when comparing items in the set. + The item to prepopulate the set with. + The type of items stored in the immutable set. + A new immutable set that contains the specified item. + + + Creates a new immutable sorted set that contains the specified array of items and uses the specified comparer. + The implementation to use when comparing items in the set. + An array that contains the items to prepopulate the set with. + The type of items in the immutable set. + A new immutable set that contains the specified items. + + + Returns a collection that can be used to build an immutable sorted set. + The type of items stored by the collection. + The immutable collection builder. + + + Returns a collection that can be used to build an immutable sorted set. + The comparer used to compare items in the set for equality. + The type of items stored by the collection. + The immutable collection. + + + Creates a new immutable collection that contains the specified items. + The comparer to use to compare elements in this set. + The items to add to the set before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Creates a new immutable collection that contains the specified items. + The items to add to the set with before it's immutable. + The type of items stored by the collection. + The new immutable set that contains the specified items. + + + Enumerates a sequence and produces an immutable sorted set of its contents. + The sequence to enumerate. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer. + The sequence to enumerate. + The comparer to use for initializing and adding members to the sorted set. + The type of the elements in the sequence. + An immutable sorted set that contains the items in the specified sequence. + + + Creates an immutable sorted set from the current contents of the builder's set. + The builder to create the immutable sorted set from. + The type of the elements in the immutable sorted set. + An immutable sorted set that contains the current contents in the builder's set. + + + Represents an immutable sorted set implementation. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of elements in the set. + + + Adds the specified value to this immutable sorted set. + The value to add. + A new set with the element added, or this set if the element is already in this set. + + + Represents a sorted set that enables changes with little or no memory allocations, and efficiently manipulates or builds immutable sorted sets. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set + + + Removes all elements from this set. + + + Determines whether the set contains the specified object. + The object to locate in the set. + + if is found in the set; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in this set. + + + Removes the specified set of items from the current set. + The collection of items to remove from the set. + + + Returns an enumerator that iterates through the set. + A enumerator that can be used to iterate through the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection. + The collection to compare to the current set. + + + Determines whether the current set is a proper (strict) subset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current set is a proper (strict) superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current set is a subset of a specified collection. + The collection is compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the set at the given index. + The 0-based index of the element in the set to return. + The element at the given position. + + + Gets a read-only reference to the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference to the element at the given position. + + + Gets or sets the object that is used to determine equality for the values in the immutable sorted set. + The comparer that is used to determine equality for the values in the set. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current set overlaps with the specified collection. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the first occurrence of the specified object from the set. + The object to remove from the set. + + if was removed from the set; if was not found in the set. + + + Returns an enumerator that iterates over the immutable sorted set in reverse order. + An enumerator that iterates over the set in reverse order. + + + Determines whether the current set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the current set is equal to ; otherwise, . + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Adds an element to the current set and returns a value to indicate whether the element was successfully added. + The element to add to the set. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether this instance is read-only. + Always false. + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + Gets a value that indicates whether access to the is synchronized (thread-safe). + + if access to the is synchronized (thread-safe); otherwise, . + + + Gets an object that can be used to synchronize access to the . + An object that can be used to synchronize access to the . + + + Returns an enumerator that iterates through the collection. + A enumerator that can be used to iterate through the collection. + + + Creates an immutable sorted set based on the contents of this instance. + An immutable set. + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + The collection to compare to the current state. + + + Removes all elements from the immutable sorted set. + An empty set with the elements removed. + + + Determines whether this immutable sorted set contains the specified value. + The value to check for. + + if the set contains the specified value; otherwise, . + + + Gets the number of elements in the immutable sorted set. + The number of elements in the immutable sorted set. + + + Gets an empty immutable sorted set. + + + Enumerates the contents of a binary tree. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The element at the current position of the enumerator. + + + Releases the resources used by the current instance of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Advances the enumerator to the next element of the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the sorted set. + + + Sets the enumerator to its initial position, which is before the first element in the immutable sorted set. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + The current element. + + + Removes a specified set of items from this immutable sorted set. + The items to remove from this set. + A new set with the items removed; or the original set if none of the items were in the set. + + + Returns an enumerator that iterates through the immutable sorted set. + An enumerator that can be used to iterate through the set. + + + Gets the position within this immutable sorted set that the specified value appears in. + The value whose position is being sought. + The index of the specified in the sorted set, if is found. If is not found and is less than one or more elements in this set, this method returns a negative number that is the bitwise complement of the index of the first element that is larger than value. If is not found and is greater than any of the elements in the set, this method returns a negative number that is the bitwise complement of the index of the last element plus 1. + + + Creates an immutable sorted set that contains elements that exist both in this set and in the specified set. + The set to intersect with this one. + A new immutable sorted set that contains any elements that exist in both sets. + + + Gets a value that indicates whether this immutable sorted set is empty. + + if this set is empty; otherwise, . + + + Determines whether the current immutable sorted set is a proper (strict) subset of the specified collection. + The collection to compare to the current set. + + if the current set is a proper subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a proper superset of a specified collection. + The collection to compare to the current set. + + if the current set is a proper superset of ; otherwise, . + + + Determines whether the current immutable sorted set is a subset of a specified collection. + The collection to compare to the current set. + + if the current set is a subset of ; otherwise, . + + + Determines whether the current immutable sorted set is a superset of a specified collection. + The collection to compare to the current set. + + if the current set is a superset of ; otherwise, . + + + Gets the element of the immutable sorted set at the given index. + The index of the element to retrieve from the sorted set. + The element at the given index. + + + Gets a read-only reference of the element of the set at the given . + The 0-based index of the element in the set to return. + A read-only reference of the element at the given position. + + + Gets the comparer used to sort keys in the immutable sorted set. + The comparer used to sort keys. + + + Gets the maximum value in the immutable sorted set, as defined by the comparer. + The maximum value in the set. + + + Gets the minimum value in the immutable sorted set, as defined by the comparer. + The minimum value in the set. + + + Determines whether the current immutable sorted set and a specified collection share common elements. + The collection to compare to the current set. + + if the current set and share at least one common element; otherwise, . + + + Removes the specified value from this immutable sorted set. + The element to remove. + A new immutable sorted set with the element removed, or this set if the element was not found in the set. + + + Returns an that iterates over this immutable sorted set in reverse order. + An enumerator that iterates over the immutable sorted set in reverse order. + + + Determines whether the current immutable sorted set and the specified collection contain the same elements. + The collection to compare to the current set. + + if the sets are equal; otherwise, . + + + Creates an immutable sorted set that contains elements that exist either in this set or in a given sequence, but not both. + The other sequence of items. + The new immutable sorted set. + + + Adds the specified value to the collection. + The value to add. + + + Removes all the items from the collection. + + + Copies the elements of the collection to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from collection. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + Removes the first occurrence of a specific object from the collection. + The object to remove from the collection. + + if was successfully removed from the collection; otherwise, . + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Inserts an item in the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + + + See the interface. + + + + Removes the item at the specified index. + The zero-based index of the item to remove. + + + Adds an element to the current set and returns a value to indicate if the element was successfully added. + The element to add to the set. + + if the element is added to the set; if the element is already in the set. + + + Removes all elements in the specified collection from the current set. + The collection of items to remove from the set. + + + Modifies the current set so that it contains only elements that are also in a specified collection + The collection to compare to the current set. + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + + + Modifies the current set so that it contains all elements that are present in either the current set or the specified collection. + The collection to compare to the current set. + + + Copies the elements of the set to an array, starting at a particular array index. + The one-dimensional array that is the destination of the elements copied from the set. The array must have zero-based indexing. + The zero-based index in at which copying begins. + + + See the interface. + + + See . + + + Returns an enumerator that iterates through a collection. + An enumerator object that can be used to iterate through the collection. + + + Adds an item to the set. + The object to add to the set. + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. + The set is read-only or has a fixed size. + + + Removes all items from the set. + Thrown in all cases. + + + Determines whether the set contains a specific value. + The object to locate in the set. + + if the object is found in the set; otherwise, . + + + Determines the index of a specific item in the set. + The object to locate in the set. + The index of if found in the list; otherwise, -1. + + + Inserts an item into the set at the specified index. + The zero-based index at which should be inserted. + The object to insert into the set. + The set is read-only or has a fixed size. + + + Gets a value that indicates whether the has a fixed size. + + if the has a fixed size; otherwise, . + + + Gets a value that indicates whether the is read-only. + + if the is read-only; otherwise, . + + + Gets or sets the at the specified index. + The index. + The . + + + + Removes the first occurrence of a specific object from the set. + The object to remove from the set. + The set is read-only or has a fixed size. + + + Removes the item at the specified index of the set. + The zero-based index of the item to remove. + The set is read-only or has a fixed size. + + + Adds the specified element to this immutable set. + The element to add. + A new set with the element added, or this set if the element is already in the set. + + + Retrieves an empty immutable set that has the same sorting and ordering semantics as this instance. + An empty set that has the same sorting and ordering semantics as this instance. + + + Removes the elements in the specified collection from the current immutable set. + The items to remove from this set. + The new set with the items removed; or the original set if none of the items were in the set. + + + Creates an immutable set that contains elements that exist in both this set and the specified set. + The collection to compare to the current set. + A new immutable set that contains any elements that exist in both sets. + + + Removes the specified element from this immutable set. + The element to remove. + A new set with the specified element removed, or the current set if the element cannot be found in the set. + + + Creates an immutable set that contains only elements that are present either in the current set or in the specified collection, but not both. + The collection to compare to the current set. + A new set that contains the elements that are present only in the current set or in the specified collection, but not both. + + + Creates a new immutable set that contains all elements that are present in either the current set or in the specified collection. + The collection to add elements from. + A new immutable set with the items added; or the original set if all the items were already in the set. + + + Creates a collection that has the same contents as this immutable sorted set that can be efficiently manipulated by using standard mutable interfaces. + The sorted set builder. + + + Searches the set for a given value and returns the equal value it finds, if any. + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + + Adds a given set of items to this immutable sorted set. + The items to add. + The new set with the items added; or the original set if all the items were already in the set. + + + Returns the immutable sorted set that has the specified key comparer. + The comparer to check for. + The immutable sorted set that has the specified key comparer. + + + Provides a set of initialization methods for instances of the class. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Creates an empty immutable stack. + The type of items to be stored in the immutable stack. + An empty immutable stack. + + + Creates a new immutable stack that contains the specified item. + The item to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable collection that contains the specified item. + + + Creates a new immutable stack that contains the specified array of items. + An array that contains the items to prepopulate the stack with. + The type of items in the immutable stack. + A new immutable stack that contains the specified items. + + + Creates a new immutable stack that contains the specified items. + The items to add to the stack before it's immutable. + The type of items in the stack. + An immutable stack that contains the specified items. + + + Removes the specified item from an immutable stack. + The stack to modify. + The item to remove from the stack. + The type of items contained in the stack. + A stack; never . + The stack is empty. + + + Represents an immutable stack. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + The type of element on the stack. + + + Removes all objects from the immutable stack. + An empty immutable stack. + + + Gets an empty immutable stack. + An empty immutable stack. + + + Enumerates the contents of an immutable stack without allocating any memory. + NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + + Gets the element at the current position of the enumerator. + The element at the current position of the enumerator. + + + Advances the enumerator to the next element of the immutable stack. + + if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the stack. + + + Returns an enumerator that iterates through the immutable stack. + An enumerator that can be used to iterate through the stack. + + + Gets a value that indicates whether this instance of the immutable stack is empty. + + if this instance is empty; otherwise, . + + + Returns the object at the top of the stack without removing it. + The object at the top of the stack. + The stack is empty. + + + Gets a read-only reference to the element on the top of the stack. + A read-only reference to the element on the top of the stack. + Thrown when the stack is empty. + + + Removes the element at the top of the immutable stack and returns the stack after the removal. + A stack; never . + The stack is empty. + + + Removes the specified element from the immutable stack and returns the stack after the removal. + The value to remove from the stack. + A stack; never . + + + Inserts an object at the top of the immutable stack and returns the new stack. + The object to push onto the stack. + The new stack. + + + Returns an enumerator that iterates through the collection. + An enumerator that can be used to iterate through the collection. + + + Returns an enumerator that iterates through a collection. + An object that can be used to iterate through the collection. + + + Removes all elements from the immutable stack. + The empty immutable stack. + + + Removes the element at the top of the immutable stack and returns the new stack. + The new stack; never . + + + Inserts an element at the top of the immutable stack and returns the new stack. + The element to push onto the stack. + The new stack. + + + LINQ extension method overrides that offer greater efficiency for than the standard LINQ methods +NuGet package: System.Collections.Immutable (about immutable collections and how to install) + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + A function to be invoked on each element, in a cumulative way. + The type of element contained by the collection. + The final value after the cumulative function has been applied to all elements. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + The type of the accumulated value. + The type of element contained by the collection. + The final accumulator value. + + + Applies a function to a sequence of elements in a cumulative way. + The collection to apply the function to. + The initial accumulator value. + A function to be invoked on each element, in a cumulative way. + + The type of the accumulated value. + The type of result returned by the result selector. + The type of element contained by the collection. + The final accumulator value. + + + Gets a value indicating whether all elements in this array match a given condition. + The array to check for matches. + The predicate. + The type of element contained by the collection. + + if every element of the source sequence passes the test in the specified predicate; otherwise, . + + + Gets a value indicating whether the array contains any elements. + The array to check for elements. + The type of element contained by the collection. + + if the array contains an elements; otherwise, . + + + Gets a value indicating whether the array contains any elements that match a specified condition. + The array to check for elements. + The delegate that defines the condition to match to an element. + The type of element contained by the collection. + + if an element matches the specified condition; otherwise, . + + + Returns a value indicating whether this collection contains any elements. + The builder to check for matches. + The type of elements in the array. + + if the array builder contains any elements; otherwise, . + + + Returns the element at a specified index in the array. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index. + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + The array to find an element in. + The index for the element to retrieve. + The type of element contained by the collection. + The item at the specified index, or the default value if the index is not found. + + + Returns the first element in an array. + The array to get an item from. + The type of element contained by the collection. + The first item in the array. + If the array is empty. + + + Returns the first element in a sequence that satisfies a specified condition. + The array to get an item from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list if it meets the condition specified by . + If the array is empty. + + + Returns the first element in the collection. + The builder to retrieve an item from. + The type of items in the array. + The first item in the list. + If the array is empty. + + + Returns the first element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve elements from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the first element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The first item in the list, if found; otherwise the default value for the item type. + + + Returns the last element of the array. + The array to retrieve items from. + The type of element contained by the array. + The last element in the array. + Thrown if the collection is empty. + + + Returns the last element of a sequence that satisfies a specified condition. + The array to retrieve elements from. + The delegate that defines the conditions of the element to retrieve. + The type of element contained by the collection. + The last element of the array that satisfies the condition. + Thrown if the collection is empty. + + + Returns the last element in the collection. + The builder to retrieve elements from. + The type of item in the builder. + The last element in the builder. + Thrown if the collection is empty. + + + Returns the last element of a sequence, or a default value if the sequence contains no elements. + The array to retrieve items from. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. + The array to retrieve an element from. + The delegate that defines the conditions of the element to search for. + The type of element contained by the collection. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Returns the last element in the collection, or the default value if the collection is empty. + The builder to retrieve an element from. + The type of item in the builder. + The last element of a sequence, or a default value if the sequence contains no elements. + + + Projects each element of a sequence into a new form. + The immutable array to select items from. + A transform function to apply to each element. + The type of element contained by the collection. + The type of the result element. + An whose elements are the result of invoking the transform function on each element of source. + + + Projects each element of a sequence to an , flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. + The immutable array. + A transform function to apply to each element of the input sequence. + A transform function to apply to each element of the intermediate sequence. + The type of the elements of . + The type of the intermediate elements collected by . + The type of the elements of the resulting sequence. + An whose elements are the result of invoking the one-to-many transform function on each element of and then mapping each of those sequence elements and their corresponding source element to a result element. + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Determines whether two sequences are equal according to an equality comparer. + The array to use for comparison. + The items to use for comparison. + The comparer to use to check for equality. + The type of element in the compared array. + The type of element contained by the collection. + + to indicate the sequences are equal; otherwise, . + + + Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence. + The array to retrieve the element from. + The type of element contained by the collection. + The element in the sequence. + + + Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists. + + + The type of element contained by the collection. + Returns . + + + Returns the only element of the array, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence. + The array. + The type of element contained by the collection. + The element in the array, or the default value if the array is empty. + + contains more than one element. + + + Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. + The array to get the element from. + The condition the element must satisfy. + The type of element contained by the collection. + The element if it satisfies the specified condition; otherwise the default element. + More than one element satisfies the condition in . + + + Copies the contents of this array to a mutable array. + + The type of element contained by the collection. + The newly instantiated array. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Creates a dictionary based on the contents of this array. + The array to create a dictionary from. + The key selector. + The element selector. + The comparer to initialize the dictionary with. + The type of the key. + The type of the element. + The type of element contained by the collection. + The newly initialized dictionary. + + + Filters a sequence of values based on a predicate. + The array to filter. + The condition to use for filtering the array content. + The type of element contained by the collection. + Returns that contains elements that meet the condition. + + + diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/useSharedDesignerContext.txt b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/useSharedDesignerContext.txt new file mode 100755 index 0000000..e69de29 diff --git a/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/version.txt b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/version.txt new file mode 100755 index 0000000..5bfde0c --- /dev/null +++ b/packages/System.Collections.Immutable.1.7.0-preview1.19504.10/version.txt @@ -0,0 +1 @@ +0498dfedf8dbbd088c74399f45bc0b0c861c831a diff --git a/project.godot b/project.godot new file mode 100644 index 0000000..fc63bf5 --- /dev/null +++ b/project.godot @@ -0,0 +1,24 @@ +; Engine configuration file. +; It's best edited using the editor UI and not directly, +; since the parameters that go here are not all obvious. +; +; Format: +; [section] ; section goes between [] +; param=value ; assign values to parameters + +config_version=4 + +_global_script_classes=[ ] +_global_script_class_icons={ + +} + +[application] + +config/name="TradingCompany" +run/main_scene="res://Stage.tscn" +config/icon="res://Images/icon.png" + +[rendering] + +environment/default_environment="res://default_env.tres"