FilterMeText is a C# based text parsing toolkit and a windows desktop application concept designed to transform unstructured text data into structured datasets suitable for analysis, reporting, and archival workflows. The project focuses on extracting meaningful content from raw text files using pattern matching (including regular expressions), organizing extracted data into tabular form, and exporting results to Microsoft Excel or structured text outputs for downstream processing.
Originally, C# was selected to accelerate development, reduce implementation overhead, and leverage robust .NET support for desktop application architecture and file-processing workflows.
The goal is to convert text files into a Microsoft Excel database or a CSV, a parsing mechanism was developed. Users familiar with regular expressions can use this tool to identify content in unstructured text files, organize findings into table format, and export the output to Microsoft Excel for additional manipulation. The project therefore represents a practical set of reusable tools intended to support development of a usable desktop application.
This repository supports the following:
- Parse unstructured text into identifiable data segments.
- Extract content using regular-expression patterns and optional filtering rules.
- Normalize extracted output into structured tabular records.
- Export transformed data to:
- Microsoft Excel-compatible formats, and/or
- structured text outputs for integration with other systems.
- Provide reusable building blocks for a desktop-based productivity tool.
FilterMeText acts as a data-ingestion and transformation layer in a text-to-table workflow:
- Input Layer: Receives raw text files from users or external systems.
- Parsing Layer: Detects patterns and delimiters in unstructured content.
- Structuring Layer: Maps parsed values to rows/columns.
- Export Layer: Writes data to Excel or normalized text files.
- User Layer (Desktop App): Provides a practical interface for operating parser tools.
Role: Handles file discovery, loading, validation, and encoding compatibility.
Responsibilities
- Open and read text files from user-selected locations.
- Validate file accessibility and format assumptions.
- Standardize text encoding (e.g., UTF-8 normalization).
- Prepare source content for parser operations.
Role: Core extraction engine that finds meaningful tokens and segments in unstructured text.
Responsibilities
- Maintain regex pattern sets and search profiles.
- Execute single-pass or iterative pattern matching.
- Capture groups and map to semantic fields.
- Handle malformed or partial pattern matches safely.
Role: Converts pattern matches into structured entities.
Responsibilities
- Convert raw matches into records (objects/rows).
- Apply transformation rules (trimming, normalization, type coercion).
- Resolve duplicate/overlapping matches.
- Track parsing confidence and rule hits (if implemented).
Role: Produces tabular representation of transformed records.
Responsibilities
- Build row-column data structures (e.g., DataTable or typed models).
- Maintain schema consistency across imports.
- Support field ordering and naming conventions.
- Prepare model for export pipelines.
Role: Serializes final table output into interoperable formats.
Responsibilities
- Write to Excel-compatible output (e.g., CSV, XLSX pipeline if supported).
- Generate structured text output (e.g., delimited, fixed-width, tagged format).
- Preserve table integrity and column metadata.
- Handle export errors and file overwrite strategy.
Role: Provides user-facing controls to run parsing operations end to end.
Responsibilities
- Accept user inputs (file selection, patterns, output type).
- Trigger parser pipeline and show progress/state.
- Display parsed previews and export status.
- Surface validation and error messages for correction.
Role: Observability and troubleshooting support.
Responsibilities
- Record parser activity and exception traces.
- Track failed matches and export failures.
- Support reproducibility through operation logs.
- Enable maintainers to diagnose data/format edge cases.
Role: Enables reusable parsing profiles and settings.
Responsibilities
- Store regex presets and transformation rules.
- Persist default export preferences.
- Support environment portability (dev/test/user).
- Reduce repetitive setup for frequent parsing tasks.
The following sequence captures the high-level execution flow:
- Input & File Management loads source text.
- Pattern/Regex Engine identifies matching fragments.
- Parsing & Transformation converts fragments into structured records.
- Data Modeling/Table Builder organizes records into a table schema.
- Export Module writes table output to Excel or structured text.
- Desktop UI orchestrates each step and communicates status.
- Logging & Diagnostics observes all stages for reliability.
This layered relationship keeps parsing logic decoupled from UI and export concerns, improving maintainability and extension potential.
- Unstructured text parsing
- Regex-based extraction
- Table-oriented data normalization
- Excel-oriented export workflow
- Structured text file generation
- Reusable parser tooling for desktop applications
- Maintainability: Separation of concerns across parsing, modeling, and export layers.
- Extensibility: New regex profiles and output formats can be added with minimal architectural changes.
- Usability: Desktop workflow aimed at non-developer operators familiar with data handling tasks.
- Reliability: Logging and validation mechanisms reduce silent parsing failures.
Adapt this section to reflect your real file layout.
/filtermitext
│
├── /src
│ ├── /Core # Parsing engine and transformation logic
│ ├── /Models # Data entities / table schemas
│ ├── /Export # Excel/text exporters
│ ├── /UI # Desktop app components
│ └── /Config # Profiles and settings
│
├── /tests # Unit/integration tests
├── /samples # Example input/output files
├── /docs # Technical documentation
└── README.md
# Clone repository
git clone https://github.com/SirDre/filtermitext.git
cd filtermitextOpen the solution in Visual Studio and build using your target .NET framework configuration.
- Launch the desktop application.
- Select an unstructured text file as input.
- Choose or define parsing/regex rules.
- Run extraction and preview tabular output.
- Export results to Excel or structured text format.
This software is licenced under the GPLv3
This is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful and if you use this software, you use it AT YOUR OWN RISK but WITHOUT ANY WARRANTY; without even the implied warranty of DAMAGES and MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU GPL.
.NET documentation. Microsoft Learn. https://learn.microsoft.com/dotnet/
Regular expression language - quick reference. Microsoft Learn. https://learn.microsoft.com/dotnet/standard/base-types/regular-expression-language-quick-reference