# Digitteck

> Productivity add-ins for Autodesk Revit and a technical blog on Revit API, C#, .NET, and BIM development.

## About

Digitteck is a software company that builds automation tools for BIM professionals working with Autodesk Revit. Products are available on the Autodesk App Store. The company also maintains a technical blog with 106 articles on Revit API development, Dynamo scripting, C#, .NET, and software architecture.

- Website: https://digitteck.com
- Blog: https://digitteck.com/blog
- Contact: ramihamati@digitteck.com

## Products

### Digitteck Suite — All-in-One Revit Add-in

The Digitteck Suite bundles four Revit productivity tools into a single installer. Designed for BIM managers and Revit users who need to automate naming, numbering, and parameter tasks across large models. Available on the Autodesk App Store for Revit 2020–2025 on Windows 64-bit.

- App Store: https://apps.autodesk.com/RVT/en/Detail/Index?id=6242939897287557677&appLang=en&os=Win64
- Product overview: https://digitteck.com/digitteck-suite-revit-addin
- Platform: Autodesk Revit 2020, 2021, 2022, 2023, 2024, 2025 — Windows 64-bit
- Pricing: $4.00/month per user. Free trial available on the Autodesk App Store.

#### AutoNumbering

Automatically numbers Revit elements — rooms, doors, windows, family instances — using configurable strategies: linear (row or column order), strip-based (by zone or bay), and curve-based (along a path). Supports configurable prefix, suffix, and sequence start. Eliminates manual Mark and Number parameter editing across large projects.

- https://digitteck.com/auto-numbering-revit-add-in

#### FamilyNames

Standardizes Revit family and type names across the project. Supports find-and-replace (including regex), bulk rename, naming rule validation, and Excel export of the full family schedule. Targets BIM managers who need to enforce naming standards before issuing models.

- https://digitteck.com/family-names

#### NameConvention

Enforces naming standards on Revit elements — views, sheets, materials, rooms, and more. Users define rule sets with wildcards or patterns; the tool scans the model, highlights non-compliant names, and applies bulk corrections in one step. Supports multilingual naming templates.

- https://digitteck.com/name-convention

#### VeloBox

Creates and manages Revit rooms from external Excel data. Teams prepare a room schedule in Excel, map columns to Revit shared parameters, and VeloBox creates or updates rooms in the model automatically. Supports bidirectional sync and multilingual data sources.

- https://digitteck.com/velo-box

#### Model QA

Consolidates Revit warnings and custom QA rules into one filterable audit view. Click any finding to navigate to the element in the active view; export the full audit to Excel for model issue logs and deliverable sign-off. No-code rule engine with 14 model sources and a searchable function reference.

- https://digitteck.com/model-qa

### Rhenergo — AI Scripting Add-in for Autodesk Revit

Rhenergo writes Revit automation from a plain-English description — IronPython scripts, Composer graphs, and windowed Apps — grounded in the real Revit API surface for the installed version, not recalled from training data. Scripts are reviewed before they run; every run reports exactly which elements were added, modified, or deleted. Supports Anthropic, OpenAI, Google Gemini (bring your own API key), and local Ollama for fully offline use. Available for Revit 2024–2027, Windows 64-bit.

- https://digitteck.com/rhenergo
- https://digitteck.com/rhenergo-revit-ai-add-in

## Frequently Asked Questions

**What is Digitteck Suite?**
Digitteck Suite is an Autodesk Revit add-in ($4.00/month per user, free trial available) that bundles AutoNumbering, FamilyNames, NameConvention, and VeloBox into one installer. It automates repetitive naming and numbering tasks in large Revit models.

**Which Revit versions does Digitteck Suite support?**
Revit 2020, 2021, 2022, 2023, 2024, and 2025. Windows 64-bit only.

**Where can I download Digitteck Suite?**
Autodesk App Store: https://apps.autodesk.com/RVT/en/Detail/Index?id=6242939897287557677

**How do I automatically number rooms in Revit?**
Use Digitteck AutoNumbering. Choose a numbering strategy (linear, strip-based, or curve-based), configure prefix/suffix and start value, and the tool numbers all selected elements in one step — no manual parameter editing. https://digitteck.com/auto-numbering-revit-add-in

**How do I enforce naming conventions in Revit?**
Use Digitteck NameConvention. Define naming rules for views, sheets, materials, and rooms; the tool flags non-compliant names and can bulk-rename them. https://digitteck.com/name-convention

**Can I create Revit rooms from an Excel spreadsheet?**
Yes, with Digitteck VeloBox. Prepare the room schedule in Excel, map columns to Revit shared parameters, and VeloBox imports and creates the rooms in the model. https://digitteck.com/velo-box

**How do I standardize family names across a Revit model?**
Use Digitteck FamilyNames. It supports find-and-replace with regex, bulk renaming, and rule-based validation, then lets you export the corrected schedule to Excel. https://digitteck.com/family-names

**Does Digitteck have technical articles on Revit API programming?**
Yes. The Digitteck blog at https://digitteck.com/revit-api-dot-net covers Revit API parameters, families, geometry, external events, transaction handling, selection filters, and more.

**Does Digitteck publish C# and .NET articles?**
Yes. https://digitteck.com/dotnet covers C#, ASP.NET Core, MongoDB, .NET Identity, gRPC, design patterns, and software architecture with 106 articles total.

**Who is Digitteck's target audience?**
BIM managers, Revit API developers, structural and MEP engineers, and architects working with Autodesk Revit. Also .NET and C# developers interested in design patterns, ASP.NET, and system architecture.

## Blog

Technical blog at https://digitteck.com/blog with 106 articles covering Revit API, Dynamo, C#, .NET, and BIM development.

### Categories

- [.NET & C#](https://digitteck.com/dotnet): C#, ASP.NET Core, MongoDB, .NET Identity, gRPC, design patterns, and system-level .NET programming.
- [Revit API](https://digitteck.com/revit-api-dot-net): Revit API — parameters, families, geometry, transactions, external events, and selection filters.
- [Algorithms](https://digitteck.com/algorithms): Computational geometry, sorting, and mathematical algorithms implemented in C# and Python.
- [Front-end](https://digitteck.com/front-end): TypeScript, Angular, React Native, and front-end architecture patterns.
- [System Engineering](https://digitteck.com/system-engineering): Distributed systems, user notification pipelines, and scalable architecture.

### Articles

- [Streaming Content into S3 with Multipart Uploads](https://digitteck.com/dotnet/streaming-content-into-s3-with-multipart-uploads): The AWS S3 SDK silently fails when uploading non-seekable streams. Learn how to use S3 multipart upload to genuinely stream chunks into S3 without loading content into memory.
- [Building a React Native Timer Hook](https://digitteck.com/frontend/typescript/building-a-react-native-timer-hook): A configurable interval-based React Native hook with pause, resume, restart, and background/foreground time recovery — with proper interval cleanup to prevent memory leaks.
- [ASP File Streams](https://digitteck.com/dotnet/asp-file-streams): How to efficiently forward large file streams through multiple ASP.NET service layers — keeping memory footprint minimal with binary request body and file signature validation.
- [.NET TCP Networking With Pipes](https://digitteck.com/dotnet/dot-net-tcp-networking-with-pippes): Building a high-performance TCP server and client in .NET using System.IO.Pipelines — reducing boilerplate while maximizing throughput through Memory/Span and rented buffers.
- [Monadic Structures](https://digitteck.com/dotnet/monadic-structures): A Result<T> monad pattern for C# — error types, typed result records, and MonadExecute helpers that chain operations through multiple service calls without relying on exceptions.
- [Mongo Batch Processes](https://digitteck.com/dotnet/mongo-csharp/mongo-batch-processes): Safely delete millions of MongoDB documents without hammering the server — using a custom IAsyncCursor enumerator, a partition helper, and a Hangfire background job with pause intervals.
- [How to Configure Options in ASP.NET](https://digitteck.com/dotnet/aspnetcore/how-to-configure-options-in-asp): Five approaches to registering and validating ASP.NET configuration options — from Configure<T> to IConfigureOptions, IValidateOptions, and data annotation validation at startup.
- [IdentityServer — Protecting an API With ClientCredentials](https://digitteck.com/dotnet/identityserver/identityserver-protect-api-clientcredentials): Minimal .NET 6 setup for protecting an ASP.NET API with IdentityServer4 ClientCredentials — IdentityServer project, API Bearer configuration, and three NUnit integration tests.
- [Option Monad](https://digitteck.com/frontend/typescript/option-monad): A TypeScript Option<T> monad for safely traversing deeply nested nullable properties — with Run, RunTransform, ValueOr, and ValueOrNull helpers that short-circuit on null/undefined.
- [Optimistic Concurrency Mongo C#](https://digitteck.com/dotnet/mongo-csharp/optimistic-concurrency-mongo-csharp): Implementing optimistic locking in MongoDB with C# using a timestamp field — a CollectionUnitOptimistic wrapper that validates the timestamp on every write and throws on conflicts.
- [Details Component — Dynamic Child Components](https://digitteck.com/frontend/angular/details-component-dynamic-child-components): Building a reusable Angular details table where row components are dynamically projected into a <tbody> using ComponentFactoryResolver and ContentChildren, keeping valid table semantics.
- [AAD Access from WebApi Secured with Certificate in KeyVault](https://digitteck.com/dotnet/aspnetcore/aad-access-from-webapi-secured-with-certificate-in-keyvault): Step-by-step guide to calling Microsoft Graph from ASP.NET Core using Azure AD client credentials with a certificate stored in Key Vault — no client secrets, managed identity auth.
- [C# Bitwise Operations](https://digitteck.com/dotnet/csharp/csharp-bitwise): Using bitwise OR, AND, XOR and complement operators in C# to compose, check, and remove permission flags — with binary visualizations showing exactly what each operation does to the bits.
- [User Notification System](https://digitteck.com/system-engineering/usernotificationsystem): A stateless, scalable user notification system using SignalR, RabbitMQ, and Redis Pub/Sub — delivering messages to all devices of a target user regardless of which server handles the connection.
- [Angular Debouncing Directive](https://digitteck.com/frontend/angular/angular-debounce-directive): An Angular directive using RxJS debounce to delay keyup events — reusable across any input without wrapper components, keeping full access to native input functionality.
- [List Partitioning](https://digitteck.com/dotnet/csharp/list-partitioning): Partitioning a list around a pivot K without sorting — comparing the classic Dutch National Flag algorithm to a simpler bidirectional swap approach that runs ~4× faster in benchmarks.
- [IdentityServer — UserManager — ResourceOwnerPassword Validations](https://digitteck.com/dotnet/identity/identity-identityserver-resourceownerpassword-validate-user): Decorating the default ResourceOwnerPasswordValidator to allow users to authenticate with email or phone number in addition to username, using a custom Mongo-based UserStore.
- [WebApi — Fake Authentication](https://digitteck.com/dotnet/tests/webapi-fake-authentication): Replacing IAuthenticationSchemeProvider in WebApplicationFactory to inject a fake user for integration tests — no JWT tokens or identity server required.
- [WebApi — Integration Test](https://digitteck.com/dotnet/tests/web-api-integration-test): Using WebApplicationFactory from Microsoft.AspNetCore.Mvc.Testing to run integration tests against a real in-process ASP.NET Core host with NUnit.
- [Identity — AddIdentity Without RoleManager](https://digitteck.com/dotnet/identity/add-identity-without-role-manager): Composing ASP.NET Identity manually to get UserManager and SignInManager without the RoleManager — starting from AddIdentityCore and adding the missing pieces.
- [C# Less Known — Manual Validation DataAnnotation](https://digitteck.com/dotnet/csharp/c-lesser-known-manual-validation-data-annotation): Using Validator.TryValidateObject from System.ComponentModel.DataAnnotations to run attribute-based validation manually outside of the ASP.NET pipeline.
- [Identity — Token Providers](https://digitteck.com/dotnet/identity/identity-tokenproviders): Inside ASP.NET Identity's default token provider setup — TokenOptions class, AddDefaultTokenProviders internals, manual per-provider registration, and per-provider UserManager API.
- [ASP.NET DataProtection](https://digitteck.com/dotnet/aspnetcore/asp-dataprotection): How ASP.NET Core Data Protection works — DI setup, factory method without DI, key storage defaults, purpose-based Protect/Unprotect isolation, and IKeyManager for key administration.
- [Identity — EFCore Store — ReplaceClaimsAsync](https://digitteck.com/dotnet/identity/identity_efcore_store_replaceclaimsasync): Exploring the EFCore UserStore ReplaceClaimAsync — why it matches claims by both type and value, the IdentityUserClaim schema without Issuer, and a cleaner refactoring proposal.
- [Revit API — Transaction Handler Pool](https://digitteck.com/dotnet/revit-api-transaction-handler-pool): A pool of generic ExternalEvent workers that accept Action<Document> — eliminating one IExternalEventHandler per operation using a concurrent queue, worker pool, and callback chain.
- [C# Less Known — TypeConverter](https://digitteck.com/dotnet/csharp/csharplesser-known-typeconverter): TypeConverter — a less-known .NET component for converting between types, using TypeDescriptor.GetConverter for built-in types and a custom converter via the [TypeConverter] attribute.
- [Identity — SignIn Debunked](https://digitteck.com/dotnet/identity/identity_signin_debunk): Tracing SignInManager.SignInAsync through every layer — SignInWithClaimsAsync, HttpContext extension, IAuthenticationService, scheme handler dispatch, and CookieAuthenticationHandler.
- [ASP.NET gRPC — Custom Error Handling](https://digitteck.com/dotnet/aspnetcore/asp-grpc-custom-error-handling): Passing typed server-side exceptions to gRPC clients via metadata — ExceptionHandler with SetException/TryGetException, [ExceptionSerializer] attribute, and a ServerExceptionInterceptor.
- [ASP.NET gRPC — OpenSSL Certificate](https://digitteck.com/dotnet/aspnetcore/asp_grpc_opensslcertificate_basic): Generating self-signed OpenSSL certificates for a gRPC server with two shell scripts, configuring Kestrel endpoints from appsettings.json, and accepting the cert on the client by thumbprint.
- [Web API MessagePack Formatter](https://digitteck.com/dotnet/aspnetcore/web-api-messagepack-formatter): Wiring MessagePack into ASP.NET Core 3 via custom InputFormatter/OutputFormatter on the server and MediaTypeFormatter on the client — with an AcceptStrict action filter and integration tests.
- [RevitAPI — Oh The Parameters](https://digitteck.com/dotnet/revitapi-oh-the-parameters): Three methods for retrieving the complete parameter set of a Revit family element — instance+symbol+family union, family document FamilyManager, and ParametersMap vs ParametersSet.
- [RevitAPI — Parameter by BuiltInParameter](https://digitteck.com/dotnet/revitapi-parameter-by-builtinparameter): Replacing the obsolete get_Parameter overload with an enumerator-based lookup that checks InternalDefinition.BuiltInParameter for typed enum-based parameter retrieval in Revit 2015+.
- [Custom Filters — Transforming Expressions](https://digitteck.com/dotnet/mongo-csharp/custom-filters-transforming-expressions): Building typed MongoDB filter helpers using Expression trees — converting a property selector + value into x => x.Property == value or x => x.List.Contains(value) at runtime.
- [IdentityServer4 — Customise Part 1 — Replacing InMemory Clients](https://digitteck.com/dotnet/identityserver/identityserver4-customizing-part-1-replacing-in-memory-clients): Replacing the default InMemoryClientStore with a custom IClientStore backed by MongoDB — swapping AddInMemoryClients for AddClientStore<T> in the IS4 startup configuration.
- [Deserializing ExpandoObject with BsonSerializer in Mongo](https://digitteck.com/dotnet/mongo-csharp/deserializing-expandoobject-with-bsonserializer-in-mongo): Two-step deserialization of a dynamic ExpandoObject into a typed class using MongoDB BsonSerializer — converting to BSON bytes first then rehydrating with the driver's own serializer.
- [Cloning an Entity with Mongo Driver](https://digitteck.com/dotnet/mongo-csharp/cloning-an-entity-with-mongo-driver): Deep-cloning a MongoDB entity with non-parameterless constructors and private setters using BsonSerializer — the driver handles what Newtonsoft JSON cannot without a custom converter.
- [IdentityServer4 — Part 6 — Protecting API — Client Credentials Example](https://digitteck.com/dotnet/identityserver/identityserver4-part-6-protecting-api-client-credentials-example): End-to-end Client Credentials flow with IdentityServer4 — setting up the Identity Server, protecting an ASP.NET Core API with JwtBearer, and calling it from a console app using IdentityModel.
- [IdentityServer4 — Part 5 — Scopes and Resources](https://digitteck.com/dotnet/identityserver/identityserver4-part-5-scopes-and-resources): Defining custom identity scopes with claims, built-in StandardScopes and JwtClaimTypes, and custom API resources in IdentityServer4 — with a full authorization code flow example.
- [Projections in Mongo C#](https://digitteck.com/dotnet/mongo-csharp/projections_in_mongo_csharp): Four ways to write MongoDB projections in C# — Builders.Projection.Expression, FindExpressionProjectionDefinition, FindAsync with FindOptions, and Include/Exclude field-level control.
- [IdentityServer4 — Part 4 — Refresh Tokens](https://digitteck.com/dotnet/identityserver/identityserver4-part-4-refresh-tokens): What refresh tokens are, when they are issued, how to exchange them using raw HttpClient, and how the IdentityModel package simplifies the authorization code and refresh token flows.
- [IdentityServer4 — Part 3 — Flows](https://digitteck.com/dotnet/identityserver/identityserver4-part-3-flows): Step-by-step breakdown of all 7 OpenID Connect flows grouped by response_type — Authorization Code, Implicit, and Hybrid variants with a summary table of channels and token types.
- [IdentityServer4 — Part 2 — GrantTypes, ResponseTypes](https://digitteck.com/dotnet/identityserver/identityserver4-part-2-grant-types-response-types): The difference between response_type and grant_type — how each maps to OAuth2 flows, the token and authorization endpoints they target, and GrantTypes in IdentityServer4.
- [IdentityServer4 — Part 1](https://digitteck.com/dotnet/identityserver/identity-server4-part1): Introduction to OAuth 2.0 and OpenID Connect — client types, front vs back channel, all four OAuth2 flows, three OpenID Connect flows, and the role of response_type vs grant_type.
- [ASP.NET Core — CORS Preflight](https://digitteck.com/dotnet/asp-net-core-cors-preflight): What CORS preflight is, what triggers it, and how to handle it — from manually adding Access-Control headers per action to the built-in ASP.NET Core CORS middleware policy.
- [Net Core Benchmark](https://digitteck.com/dotnet/csharp/net-core-benchmark): Using BenchmarkDotNet to measure .NET method performance — MemoryDiagnoser, MediumRunJob, ArgumentsSource, and reading the results table including skewness and allocation columns.
- [Http Client — HttpContent and Faking Message Handler](https://digitteck.com/dotnet/csharp/http-client-contents-and-faking): Three HttpContent types in .NET — FormUrlEncodedContent, StringContent, StreamContent — and how to replace HttpClientHandler with a FakeMessageHandler for unit testing.
- [Families, Symbols, Instances & System Families](https://digitteck.com/dotnet/families-symbols-instances-and-system-families): The Revit API hierarchy of Family, FamilySymbol, and FamilyInstance — with FilteredElementCollector queries for instances, families, system types, and navigating between them.
- [.NET Core ServiceProvider — ActivatorUtilities — ObjectFactory](https://digitteck.com/dotnet/csharp/net-core-serviceprovider-activatorutilities-objectfactory): Building a .NET Core DI container with ServiceCollection, then using ActivatorUtilities.CreateInstance and CreateFactory to instantiate non-registered objects that mix services and runtime args.
- [Day Suffix Using a Custom Formatter](https://digitteck.com/dotnet/csharp/day-suffix-using-a-custom-formatter): Implementing IFormatProvider and ICustomFormatter to add ordinal day suffixes (1st, 2nd, 3rd) to DateTime output via string.Format — using custom "nn" tokens and switch-based suffix logic.
- [Parameters in Revit API](https://digitteck.com/dotnet/parameters-in-revit-api): Retrieving Revit parameters by BuiltInParameter, name, and ordered list — reading and setting values by StorageType, and converting between internal and display units with UnitUtils and LabelUtils.
- [Filters in Mongo C#](https://digitteck.com/dotnet/mongo-csharp/filters-in-mongo-csharp): Five ways to write MongoDB filters in C# — LINQ expressions, Builders FilterDefinition, ExpressionFieldDefinition with the & operator, StringFieldDefinition, and the IN operator.
- [Revit API — Custom Selection Filter](https://digitteck.com/dotnet/revit-api-custom-selection-filter): Implementing ISelectionFilter to restrict user selection in a Revit add-in — using BuiltInCategory to allow only door elements through PickElementsByRectangle.
- [Value Objects and Mongo Serializer](https://digitteck.com/dotnet/mongo-csharp/value-object-and-mongo-serializer): Writing a custom IBsonSerializer to store a value object as its primitive value in MongoDB — avoiding the default nested document expansion with BsonSerializerAttribute.
- [Value Object](https://digitteck.com/dotnet/value-object): Building a generic ValueObject<T> base class in C# — implementing IComparable, IEquatable, operator overloads, and an implicit conversion operator to eliminate primitive obsession.
- [C# Wrapping Hierarchy](https://digitteck.com/dotnet/csharp-wrapping-hierarchy): Mirroring a third-party class hierarchy in your own wrapper layer using a generic IWrapper<T> interface implemented twice — preserving the parent–child relationship for typed collections.
- [C# class vs struct (IL and Memory)](https://digitteck.com/dotnet/csharp-class-vs-struct): How classes, structs, and enums map to IL — all extend a class at the CLR level — and why struct fields live at the struct's own memory address while class fields are offset from the object pointer.
- [ASP.NET — Controller Action to Controller Command Class](https://digitteck.com/dotnet/asp-net-core-command-pattern): Extracting controller action logic into a dedicated command class that inherits Controller — giving it full access to HttpContext, View(), and routing without a wrapper property.
- [Dynamo AutoCAD — Interop Connection with C# — Part 2](https://digitteck.com/dotnet/dynamo-autocad-interop-connection-with-csharp-part2): Querying an open AutoCAD document from a C# console application via COM interop — reading active layers, model space, layouts, and open documents using AcadApplication.
- [Dynamo Python — Dictionaries from Python to Graph](https://digitteck.com/dotnet/dictionaries-from-python-to-graph): Why a Python dict cannot be consumed by Dynamo nodes downstream, and how to use System.Collections.Generic.Dictionary from Python to produce a native Dynamo Dictionary output.
- [Dynamo Python — Distribute Lines Along Curve](https://digitteck.com/dotnet/dynamo-python-distribute-lines-along-curve): A Dynamo Python script that places perpendicular lines at parameter positions along a polycurve, interpolating their lengths across multiple input target lengths.
- [Dynamo AutoCAD — Interop Connection with C#](https://digitteck.com/dotnet/dynamo-autocad-interop-connection-with-c): Establishing a live COM Interop connection to a running AutoCAD process from a C# Dynamo node — using Marshal.GetActiveObject and Activator.CreateInstance with versioned ProgId.
- [C# — Projecting a Point onto a Line by a Direction](https://digitteck.com/altgorithms/projecting-point-onto-line-direction): Finding the intersection of a directional ray from point C with line AB using parametric line equations — solving two simultaneous parametric equations for the parameter t on AB.
- [Class Attributes](https://digitteck.com/dotnet/class-attributes): Using custom C# attributes and reflection to tag filter classes with their data type category — eliminating duplicate definitions and enabling a self-registering dictionary pattern.
- [RevitAPI — Getting Parameters](https://digitteck.com/dotnet/revitapi-getting-parameters): Retrieving room, door, and window parameter values via get_Parameter(BuiltInParameter) — reading doubles, strings, and ElementIds with HasValue guards for safe access.
- [Family Instance Location](https://digitteck.com/dotnet/family-instance-location): Getting a Revit family instance's XYZ position — using LocationPoint for free-standing elements and HostParameter + Curve.Evaluate for wall-hosted elements like doors and windows.
- [TypeScript Extensions](https://digitteck.com/frontend/typescript/extensions): Adding methods to existing TypeScript types using prototype extension and interface declaration merging — illustrated by adding Aggregate, All, Any, and First to Array.
- [Get Revit Elements with a Certain Level](https://digitteck.com/dotnet/get-revit-elements-with-a-certain-level): Using FilteredElementCollector with OfCategory and ElementLevelFilter to retrieve all doors on a specific level — combining fast and slow filters for efficient querying.
- [Dynamo - WCF Basic Soap Service](https://digitteck.com/dotnet/dynamobimdotnet/dynamo-wcf-basic-soap-service): Creating a WCF SOAP service in .NET and consuming it from Dynamo using ChannelFactory — offloading heavy computations to a server machine shared by multiple Dynamo users.
- [Dynamo - Database Sqlite Connection Model](https://digitteck.com/dotnet/dynamo-database-sqlite-connection-model): A scalable approach to reading SQLite data in Dynamo using typed FieldResult, RowResult, and TableResult business models exposed as dedicated ZeroTouch nodes.
- [Dynamo - Database Sqlite Connection](https://digitteck.com/dotnet/dynamo-database-sqlite-connection): Setting up a SQLite database with DB Browser and connecting to it from Dynamo using C# and the System.Data.SQLite NuGet package to read table rows.
- [Factory Design Pattern](https://digitteck.com/dotnet/factory-design-pattern): The factory pattern decouples object creation from consumers using a factory method interface — adding new types requires only a new class, not edits to existing switch statements.
- [Revit External Event](https://digitteck.com/dotnet/revitapidotnet/revit-external-event): Wrapping ExternalEvent and Transaction in a custom IRevitActionHandler interface that works in both a live Revit add-in and a plain WPF test project without Revit context.
- [Reading xml file with python in Dynamo](https://digitteck.com/dotnet/reading-xml-file-with-python-in-dynamo): Using System.Xml from IronPython in Dynamo to load and traverse XML documents — XmlDocument, GetElementsByTagName, ChildNodes, and attribute access.
- [Bridge Design Pattern](https://digitteck.com/dotnet/bridge-design-pattern): The bridge pattern decouples abstraction from implementation so both can vary independently — illustrated with shapes holding color references instead of inheriting them.
- [Dynamo Python Tips](https://digitteck.com/dotnet/dynamo-python-tips): Essential IronPython tips for Dynamo: creating Revit geometry with Autodesk.Revit.DB, modifying the model via TransactionManager, and retrieving elements by ElementId.
- [Geometry Conversions in Dynamo with Python](https://digitteck.com/dotnet/geometry-conversion-in-dynamo-with-python): Using RevitNodes.dll geometry conversion extension methods in IronPython to convert between DesignScript types and Revit DB types — Point, Vector, Solid, Curve, and Transform.
- [Memento Design Pattern](https://digitteck.com/dotnet/memento-design-pattern): The memento pattern captures an object's state for later restoration using three actors: Originator, Memento, and Caretaker — the foundation of undo/redo.
- [Dynamo Lists - Levelize List](https://digitteck.com/dotnet/dynamo-lists-levelize-list): A recursive IronPython custom node that makes two Dynamo lists structurally identical by filling length gaps with None, paired items, a fixed value, or the last seen item.
- [Adapter Design Pattern](https://digitteck.com/dotnet/adapter-design-pattern): The adapter pattern bridges incompatible interfaces by wrapping an adaptee in a class that implements the target interface — illustrated with an old gas-car adapted to an electric-car interface.
- [Decorator Design Pattern](https://digitteck.com/dotnet/decorator-design-pattern): The decorator pattern adds behaviour to objects at runtime by wrapping them in decorator classes — more flexible than static inheritance, illustrated with composable pizza toppings.
- [Interface Composables](https://digitteck.com/dotnet/interface-mixing): Using a shared IFilter<T> interface for both single-predicate filters and composite filter groups — the consumer calls the same Pass() method whether it holds one rule or a nested tree.
- [Backtracking - N Queens](https://digitteck.com/altgorithms/backtracking-n-queens): Solving the N-Queens problem with recursive backtracking in C# — place N queens on an N×N board so none can attack another, collecting all 92 solutions for N=8.
- [Interface With Events](https://digitteck.com/dotnet/interface-with-events): Exposing events at the interface layer in C# using explicit add/remove accessors that forward subscriptions to the underlying base-class event.
- [Insertion Sort Of Property](https://digitteck.com/dotnet/insertion-sort-of-property): A Dynamo node that sorts a flat list of objects by any named numeric property using reflection and insertion sort — elements and their values are reordered together.
- [QuickHull - Divide and conquer](https://digitteck.com/altgorithms/quickhull-divide-and-conquer): Implementing the QuickHull convex hull algorithm in IronPython for Dynamo — divide-and-conquer approach with Θ(n log n) average complexity, using cross-product point-side classification.
- [Element Design Option](https://digitteck.com/dotnet/element-design-option): A Dynamo Python script to retrieve the Design Option name for a set of Revit elements, enabling filtering by design option in your graphs.
- [Sagitta](https://digitteck.com/altgorithms/sagitta): A computational design approach to the sagitta — the perpendicular height from a chord's midpoint to an arc — implemented as a reusable Dynamo custom node.
- [Parametric equation of circle and ellipse](https://digitteck.com/altgorithms/parametric-equation-of-circle-and-ellipse): Applying the parametric equations of a circle and ellipse in Dynamo to generate computational geometry, including spirals, 3D forms, and heart shapes.
- [Wpf Notes - 01 - Custom User Control](https://digitteck.com/dotnet/wpf-notes-01-custom-control): How to build a reusable WPF UserControl in C# with DependencyProperties, demonstrated by creating a circular info badge with XAML bindings.
- [SepparateCurvesByDistance](https://digitteck.com/dotnet/sepparatecurvesbydistance): A Dynamo Python node that groups imported curves from Revit into connected sets based on proximity, using a configurable maximum distance threshold.
- [Replace Conditional IF with polymorphism](https://digitteck.com/dotnet/replace-conditional-polymorphism): Replace deeply nested if/switch conditionals with polymorphism and the Strategy Pattern for cleaner, extensible OOP code.
- [Lists of generic items with different types](https://digitteck.com/dotnet/when-hiding): Explores the pitfalls of using the `new` keyword to hide base class members in generics, and the correct pattern using abstract methods.
- [Switch Enum - Refactoring](https://digitteck.com/dotnet/switch-enum-refactoring): Refactor complex enum-based switch statements using the Strategy Pattern with a dictionary of actions, improving readability and scalability.
- [Double Sort](https://digitteck.com/dotnet/dynamo-double-sort): A custom Dynamo Python node that sorts two parallel lists together, keeping their relative order in sync — useful when sorting lines by length.
- [Refactoring sequences](https://digitteck.com/dotnet/refactoring-sequences): Learn how to reduce client-side exposure by wrapping sequences in a CompositeWorker and factory, so callers never deal with iteration logic.
- [String Destructuring](https://digitteck.com/dotnet/string-destructuring): A C# StringDestructure class that splits a string into two lists by a predicate, transforms each part independently, then recomposes the result.
- [Getting rooms with python in Dynamo](https://digitteck.com/dotnet/getting-rooms-python-dynamo): How to get all rooms in Revit using Python inside Dynamo, filtering by SpatialElement with the FilteredElementCollector.
- [Behavior of TextBox elements](https://digitteck.com/dotnet/behavior-textbox-elements): A WPF TextboxStrict helper class that uses regex validation to prevent users from entering invalid characters in a TextBox.
- [Getting al rooms with c#](https://digitteck.com/dotnet/getting-al-rooms-c): How to retrieve all rooms in Revit using C# by filtering on SpatialElement rather than Room type directly.
- [Reverse Flatten](https://digitteck.com/dotnet/reverse-flatten): A custom Dynamo node written in Python that reverses the Flatten operation, starting from the last level of a multi-dimensional list.
- [Rotate a Revit Element](https://digitteck.com/dotnet/rotate-revit-element): How to rotate a Revit element using ElementTransformUtils in Dynamo Python without modifying the rotation parameter directly.
- [Recursivity to handle multi-dimensional arrays](https://digitteck.com/dotnet/recursivity-handle-multi-dimensional-arrays): A recursive Python pattern for Dynamo that walks multi-dimensional lists of any depth and applies a custom function to each leaf element.
- [Determine if an object is iterable](https://digitteck.com/dotnet/determine-object-iterable): A Python snippet for Dynamo that correctly detects whether an input is iterable, handling both native Python types and .NET System.Array.
- [Quick Workaround To GUI Update In Property Change Of Observable Collection](https://digitteck.com/dotnet/quick-workaround-gui-update-property-change-observable-collection)
- [Start coding for Dynamo in C#](https://digitteck.com/dotnet/start-coding-dynamo-c): How to set up a C# library for Dynamo using NuGet and use the ArbitraryDimensionArrayImport attribute to support multi-dimensional list lacing.
- [Using UIModel Class For Binding In WPF](https://digitteck.com/dotnet/using-uimodel-class-binding-wpf): A reusable UIModel base class that uses reflection and DisplayAttribute to programmatically bind WPF dependency properties without losing designer preview.