A few Penguin objects, most notibly a TreeNode object that parses and "leafs" IEnumerables of objects based on a user-defined string produced by a func. Useful for turning lists of paths into navigatable tree structures. This allows for removing recursive key references on data tables simplifying data schema
Important: call builder.UseMindFusionDiagramming() from CreateMauiApp. MindFusion.Diagramming adds to applications the ability to create and present flowchart and process diagrams, workflow and data flow charts, database entity-relationship diagrams, organizational and classification charts, hierarchy and relationship diagrams, networks, graphs, trees, and more. The basic diagram elements - shapes, links, tables, and containers - can be grouped and attached to each other to form complex structures. The control provides many predefined shapes and the ability to define custom ones. The elements can display rich content, such as formatted text and images. The appearance can be customized through a flexible styling system, node effects, and many built-in themes. The control provides a comprehensive collection of automatic layout algorithms, including Spring-Embedder, Grid, Annealing, Circular, Orthogonal, Topological, Cascade, Triangular, Layered, FlowChart, Workflow, Hierarchical, and multiple Tree layouts.
JSON will be transformed into a tree structure of the key of Dictionary, and use the Find(key1).Find(key2) method to get object.
Fuaran.Core.Propagation — change propagation over a reference DAG + tree-level dirty recomputation for a domain tree whose cross-node references are declared bindings on permanent ids. Derives the dependency map from a per-call readsOf function (no witness field), the dependency order + reference-cycle enumeration (Tarjan SCC, cycles as data), and the minimal dirty set from a value change or a structural SkeletonOp (reverse-reachability closure). Owns no evaluator (recompute stays domain-side); staleness is a returned Set. The graph questions are Fuaran.Core.Relation's one iterative pass (no stack depth limit on a dependency chain); a prepared Plan is reused across incremental ticks. FSharp.Core only, Fable-clean.
An abp module that provides standard tree structure entity implement.
MoreComplexDataStructures is a class library containing a collection of data structures (plus related utility classes) more complex than those found in the standard .NET framework. The project currently contains the following data structures and utility classes... WeightBalancedTree<T> - A weight-balanced binary search tree MinHeap<T> - A tree-based min heap MaxHeap<T> - A tree-based max heap PriorityQueue<T> - A tree-based double-ended priority queue Trie<T> - A trie (or prefix tree) CharacterTrie - A trie which stores characters (with some performance enhancements over Trie<Char>) WeightedRandomGenerator<T> - A weighted random number (or item) generator UniqueRandomGenerator - A random number generator guaranteed to always produce unique numbers within a given range FrequencyTable<T> - A frequency table LRUCache<TKey, TValue> - A simple least recently used cache UnflaggedNumberGenerator - Allows the 'flagging' (marking) of numbers in a specified range, and provides methods to identify numbers which were not flagged LongIntegerStatusStorer - Stores a boolean status for a complete set of long integers ListRandomizer - Randomizes the elements of a list using the Fisher/Yates/Knuth algorithm
TreeBasedCli is a C# library that simplifies the process of creating command-line interfaces (CLIs) with nested subcommands. This library is designed to help developers build CLIs that offer an intuitive and user-friendly experience, with clear and concise documentation and actionable error messages to guide users through the command tree. With TreeBasedCli, you can easily organize and structure your CLI's functionality, and take advantage of native support for asynchronous command execution and customizable dependency injection. Whether you're building a small personal CLI or a larger, more complex application, TreeBasedCli is a powerful choice that helps you create CLIs that provide a seamless and enjoyable experience for your users.
Creates an ASCII tree of any structure (visualize a tree using characters only)
MindFusion.Diagramming for Blazor adds to applications the ability to create and present flowchart and process diagrams, workflow and data flow charts, database entity-relationship diagrams, organizational and classification charts, hierarchy and relationship diagrams, networks, graphs, trees, and more. The basic diagram elements - shapes, links, tables, and containers - can be grouped and attached to each other to form complex structures. The control provides many predefined shapes and the ability to define custom ones. The elements can display rich content, such as formatted text and images. The appearance can be customized through a flexible styling system, node effects, and many built-in themes. The control provides a comprehensive collection of automatic layout algorithms, including Spring-Embedder, Grid, Annealing, Circular, Orthogonal, Topological, Cascade, Triangular, Layered, FlowChart, Workflow, Hierarchical, and multiple Tree layouts.
Explore trees and tree-like structures with LINQ using tree-traversal algorithms like breadth-first and depth-first search: IEnumerable<DirectoryInfo> childDirectories = Traverse.DepthFirst(new DirectoryInfo(...), d => d.EnumerateDirectories()); IEnumerable<DirectoryInfo> parentDirectories = Traverse.Along(new DirectoryInfo(...), d => d.Parent);
Elementary Hierarchy provides interfaces, data structures and algorithms for developing of hierarchical data structures.
Advanced data structures for .NET
QuickGraph provides generic directed/undirected graph datastructures and algorithms for .NET Standard 2.0 QuickGraph comes with algorithms such as depth first seach, breath first search, A* search, shortest path, k-shortest path, maximum flow, minimum spanning tree, least common ancestors, etc...
Grapes it is an utility library which takes care of mapping tree-like data structures into database. Probably you want to install Brandy.Grapes.NHibernate or Brandy.Grapes.FluentNHibernate
This is a C# library designed for effectively handling tree structures. Emphasizing flexibility and extensibility, the library allows easy manipulation of various tree structures. Features: A rich set of extension methods for `ITreeNode<TNode>` Mutual referencing between parent and child nodes A collection of tree-structured classes with high extensibility Conversion between different data structures and tree structures Generic utility classes needed for implementing the above features
Code block and Mermaid diagram summarization for RAG pipelines. Uses Tree-sitter for AST parsing of 28+ languages and regex-based Mermaid parsing for diagram structure extraction.
This .NET/Mono library provides some utilities for handling tree structures. Most importantly, it supports the display of tree structures as two-dimensional graphics. By using ready-made interfaces, you can specify the size of your nodes, and the Tree Layout Helper library will take care of placing those nodes appropriately.
General-purpose utility library: string, date/time, decimal, numeric, collections, LINQ, streams, tasks, expressions, translations, chain-of-responsibility, round-robin, and tree structures. Zero dependencies.
Flow Event Explorer is a powerful XrmToolBox plugin designed to help Dynamics 365 and Power Platform users easily explore and manage Power Automate flows associated with specific entities. The plugin displays a tree-like structure similar to the Plugin Registration tool, allowing users to see all the flows triggered by various events on each entity. This tool simplifies the process of identifying and managing flow dependencies, ensuring a streamlined and efficient automation process
Grapes it is an utility library which takes care of mapping tree-like data structures into database.
MASBicudo Data Structures - Immutables, Continuous.
FSharp library which implements different data structures.
Compile-time C# mapping generator for handwritten mappings, LINQ expression projections, update-in-place overloads, and explicit structural adaptations.
Object-Tree validation tools. Simple and readable validation of the structure and data of any object tree. Validation assertions can be either INamedPredicates or NUnit assertion constraints.
Interface and extension methods for managing binary tree structures.
Convert any .NET lambda/expression tree into a fully structured, serialization-friendly model (JSON) and rebuild the exact expression back. Supports every ExpressionType, the complete Queryable surface, closures, anonymous types, IQueryable pipelines with re-bindable roots, root-anchored typed models with type inference, and DTO→entity expression casting.
Promptuarium is a versatile, tree-based data structure to store or exchange data and metadata efficiently (in binary format). Written in pure C#, can be used in F#, too.
.NET implementations of common spatial indexing structures such as binary space partioning trees.
A .NET library containing various data structures and algorithms, such as random-access lists and finger trees.
Fuaran incremental re-derivation engine — effect-aware memoisation over the Phase 180 artifact-function apply. Caches substituted fragment trees keyed by (function-identity, arg-set); a value-parameter change reuses the structural tree and recomputes only the affected hole-addressed bindings; effecting functions bypass the cache; op-stream replay resolves through the cache to a byte-identical tree. Apache-2.0 licensed.
ExtendibleTreeStructure is a .NET package that allows easy configuration of tree structures that need to be copied to some other trees with new parents and children. The package allows providing as an input collections (called data stores in subsequent text) of simple objects (called data store items in subsequent text) that have minimum state (id, parent id, priority, id and data store id of copied data store item, etc). The classes in this package construct proper tree structures for each data store. Good example of application of ExtendibleTreeStructure package is when we want to configure menu structure of a project (say in xml file). Lets say some part of the menu structure is common for all file types (e.g., File Menu with Exit, Save, SaveAs menu items, Edit menu with search, etc). Also, lets suppose that the project supports C# and image file types, that support some additional functionality, and require new menu items on top of common (shared) menu structure. In this scenario we can provide a menu data store with shared data store items. Then we can define two more data stores for these two file types, with additional data store items (menu items) specific to these file types. In these new data stores we can copy the data store items in shared data store while spcifying new parent id (or no parent at all). Say we can copy File menu bar to data store for C# file type, and add new data store item for 'Compile' with parent id equal to id of File menu bar data store item. In other words, we specify copy data store items (data store items that specify the referenced data store item data id), with new parent id (or no parent id at all). Also, we can add new data store items with parent Ids equal to ids of children of copied data store items (i.e., add new children to children of copied data store items). The classes in this package will create tree structures in all the specified data stores with proper parent/children relationship, and will make sure the referenced (copied) data store items are copied under new parents (or are copied as top level data store items). Also, the package logs any errors, and prevents circular references that might otherwise result via parent/reference relationships. The git repository https://github.com/artakhak/ExtendibleTreeStructure has more detailed documentation, along with the source code and tests project ExtendibleTreeStructure.Tests with good examples.
Grapes it is an utility library which takes care of mapping tree-like data structures into database.
General purpose data structures and algorithms mostly to cover the functionallity or performance gap in the framework. Includes: ProrityQueue, Bag, SymboleTable, Trie, UnionFind, Search Trees (BST, OST, RBT), sorting and graph algorithms.
Library that provides simple materialized path tree structure for EF Entities
AVL and Binary Search Tree data structures and traversal algorithms, such as: BFS and 3 variants of DFS
MoreStructures is a library of classical algorithms and data structures, written 100% in (safe, managed) C# 10, for .NET 6 and above. Data structures - Stacks, Queues, Priority Queues, Disjoint Sets, Trees, Graphs, Suffix Trees, Suffix Tries. Algorithms - Strings sorting and matching. Lists searching and sorting. Trees augmentation and visit. Graphs: visits, minimum spanning tree, shortest distance, shortest path, topological sorting, strongly connected components. Suffix Trees and Tries construction and matching.
Fuaran.Core.Column.Ops — a columnar op-algebra over Fuaran.Core.Column's Table (SetCell / SetColumn / InsertColumn / RemoveColumn / AppendRows / ApplyTransform) with a total apply / canApply, a partial invert (undo/redo), a structural Diff, a canonical wire codec, and a Fuaran.Core.OpStream StreamWitness — so table edits become an append-only, hash-chained, replayable, tamper-evident stream (the columnar analogue of the tree op-stream). No base type, no new witness field (the op DU is self-contained over Table; OpStream stays generic over its (apply, encode, decode) witness). FSharp.Core only, Fable-clean.
MindFusion.Diagramming adds to applications the ability to create and present flowchart and process diagrams, workflow and data flow charts, database entity-relationship diagrams, organizational and classification charts, hierarchy and relationship diagrams, networks, graphs, trees, and more. The basic diagram elements - shapes, links, tables, and containers - can be grouped and attached to each other to form complex structures. The control provides many predefined shapes and the ability to define custom ones. The elements can display rich content, such as formatted text and images. The appearance can be customized through a flexible styling system, node effects, and many built-in themes. The control provides a comprehensive collection of automatic layout algorithms, including Spring-Embedder, Grid, Annealing, Circular, Orthogonal, Topological, Cascade, Triangular, Layered, FlowChart, Workflow, Hierarchical, and multiple Tree layouts.
The merge of the Fuaran op-stream DAG, which is Fuaran.Core's DAG over the op envelope: a thin reconciliation policy over Core's conflict report (agreement, a declared child-order rule, a reorder rebase, every other interfering pair refused with a typed envelope), an optional precedence-as-script side, the validator gate, and Core's replay, checkpoints and compaction bound to the tier. A merge node records its script and is checked to replay to the derived tree. Requires IDagOpStreamSink, so DAG behaviour is structurally unreachable from the linear path. Apache-2.0 licensed.
A library for all the data structures in C#. Every class is generic and reusable.
Fuaran signature-searchable pattern bank — a public, Fable-clean façade over the Fuaran.Core artifact-function registry. Deterministic, LLM-free, server-free structural retrieval of UI patterns ("given the holes I can fill and/or the kind of node I want, which known patterns can I run?"), plus a curated domain-neutral seed catalogue that instantiates into real Fuaran trees. Apache-2.0 licensed.