DEV Community: Steven Kamwaza

Stop Wiring Quill by Hand: RazorRichText for ASP.NET Core

Steven Kamwaza — Fri, 25 Sep 2026 07:54:00 +0000

Adding a rich text box to an ASP.NET Core app usually means three separate jobs: embed Quill, keep the HTML out of XSS trouble, and teach model validation that   is empty. RazorRichText is a MIT-licensed NuGet package that does those jobs for you.

You bind a string with asp-for. On POST you get sanitised HTML. The editor itself is a tag helper, so the view stays markup.

dotnet add package RazorRichText

It targets ASP.NET Core on .NET 10 and ships Quill plus the editor CSS and JS as embedded assets. You do not host those files yourself.

Wire it once

Program.cs needs two calls: register the services, then map the embedded files. UseEmbeddedAssets is on by default, so the map call is required.

using RazorRichText.Extensions;
using RazorRichText.Models;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddRazorRichText(opts =>
{
    opts.DefaultHeight = 360;
    opts.DefaultPlaceholder = "Start writing…";
    opts.DefaultPreset = ToolbarPreset.Blog;
    opts.SanitizeByDefault = true;
    opts.CleanPasteFromWord = true;
});

var app = builder.Build();

app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();

app.MapRazorRichTextAssets();   // serves /_razor-rich-text/*.css and *.js
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Prefer config over code? Bind the RazorRichText section:

builder.Services.AddRazorRichText(builder.Configuration);

{
  "RazorRichText": {
    "DefaultHeight": 400,
    "DefaultTheme": "Dark",
    "DefaultPlaceholder": "Start writing…",
    "SanitizeByDefault": true,
    "CleanPasteFromWord": true,
    "MaxContentLength": 20000
  }
}

In Views/_ViewImports.cshtml:

@using RazorRichText.Models
@using RazorRichText.Helpers
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@addTagHelper *, RazorRichText

In Views/Shared/_Layout.cshtml, inside <head>:

@Html.RenderRichTextAssets()

Call that helper once in the layout. If the toolbar paints but formatting does nothing, Quill was loaded twice. Set AutoIncludeScripts = false and keep the single layout call.

A model that understands HTML

A normal [Required] or [StringLength] attribute counts tags. A bold word is longer than the same word in plain text, and an untouched Quill editor posts  , which is not empty to [Required].

Mark the property with [RichText]. That tells the binder to sanitise the value before your action runs. Length rules measure the plain text.

using System.ComponentModel.DataAnnotations;
using RazorRichText.Models;
using RazorRichText.Services;

public class ArticleForm
{
    [Required, StringLength(200)]
    public string Title { get; set; } = "";

    [RichText]
    [RequiredRichText(ErrorMessage = "Write the article before publishing.")]
    [MinRichTextLength(50)]
    [MaxRichTextLength(20_000)]
    [Display(Name = "Body")]
    public string Body { get; set; } = "";

    [RichText]
    [MaxRichTextLength(280)]
    public string Summary { get; set; } = "";
}

The view is one element per field:

@model ArticleForm

<form method="post">
    @Html.AntiForgeryToken()

    <label asp-for="Title"></label>
    <input asp-for="Title" />
    <span asp-validation-for="Title"></span>

    <label asp-for="Body"></label>
    <rich-text-editor asp-for="Body"
                      rte-preset="Blog"
                      rte-height="420"
                      rte-placeholder="Type / for a heading, list, or quote." />
    <span asp-validation-for="Body"></span>

    <button type="submit">Publish</button>
</form>

The controller stays a normal MVC action. model.Body is already cleaned when it arrives.

[HttpPost, ValidateAntiForgeryToken]
public IActionResult Create(ArticleForm model)
{
    if (!ModelState.IsValid)
        return View(model);

    // model.Body is sanitised HTML. Store it.
    return RedirectToAction(nameof(Index));
}

builder.Services.AddControllersWithViews(options =>
    options.ModelBinderProviders.Insert(0, new RichTextModelBinderProvider()));

Without the binder, inject IHtmlSanitizerService and call Sanitize yourself. The result tells you whether anything was stripped, which is useful in an audit log.

Pick a preset instead of a button list

The default chrome is slash-first: type / for commands, and a small bubble appears when text is selected. Presets choose which commands exist, so a comment box and a docs editor do not share one giant toolbar.

Preset	What the author gets
`Comment`	Bold, italic, underline, strikethrough, links
`Chat`	Comment, plus lists
`Blog`	Headings, lists, links, images, quotes, undo
`Docs`	Blog, plus alignment, code, find and replace
`Full`	Every group, including tables, colours, source view

A comment field that stays out of the way until it is focused:

<rich-text-editor asp-for="Comment"
                  rte-preset="Comment"
                  rte-toolbar="Slash"
                  rte-appearance="Ghost"
                  rte-height="140"
                  rte-status-bar="false"
                  rte-placeholder="Add a comment…" />

Ghost draws the border only while the editor is focused. Plain is unstyled chrome for apps that already have a design system. Themed is the default look (light, dark, or high contrast via rte-theme).

A documentation editor with the classic ribbon:

<rich-text-editor asp-for="Body"
                  rte-preset="Full"
                  rte-toolbar="Standard"
                  rte-appearance="Themed"
                  rte-theme="Dark"
                  rte-height="480"
                  rte-sticky-toolbar="true" />

# followed by space still becomes a heading, and pasting from Word is cleaned up (CleanPasteFromWord defaults to true). You can ignore the presets and pass groups directly: rte-toolbar-groups="TextFormatting,Lists,Links". Use the flag name only — All, not ToolbarGroups.All.

Show the saved article

@Html.Raw on stored HTML is fine only after sanitising. The display helper is the safer default, and it can build a table of contents from the headings:

@Html.RichTextDisplay(Model.Body, cssClass: "prose", showToc: true, printFriendly: true)

Listing pages rarely want the full HTML. Inject IContentConverter:

public sealed class ArticleService(IContentConverter converter)
{
    public string Excerpt(string html) => converter.GetExcerpt(html, 160);

    public int Words(string html) => converter.CountWords(html);

    public string AsMarkdown(string html) =>
        converter.HtmlToMarkdown(html).Content;
}

The same service converts Markdown back to HTML, or strips tags to plain text, when you already store one format and need another.

Drafts and images

Autosave writes to localStorage under rte_autosave_{editorId} and restores the draft when the server has no value yet.

<rich-text-editor asp-for="Body"
                  rte-preset="Blog"
                  rte-autosave="true"
                  rte-autosave-interval="15000" />

Images need an endpoint that accepts multipart/form-data (file) and returns { "url": "/uploads/….jpg" }.

<rich-text-editor asp-for="Body"
                  rte-preset="Blog"
                  rte-allow-images="true"
                  rte-image-url="/api/images/upload" />

[ApiController]
[Route("api/images")]
public class ImageUploadController(IWebHostEnvironment env) : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> Upload(IFormFile file)
    {
        var allowed = new[] { "image/jpeg", "image/png", "image/gif", "image/webp" };
        if (file is not { Length: > 0 } || !allowed.Contains(file.ContentType))
            return BadRequest(new { error = "Unsupported image." });

        var dir = Path.Combine(env.WebRootPath, "uploads");
        Directory.CreateDirectory(dir);

        var name = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}";
        await using var stream = System.IO.File.Create(Path.Combine(dir, name));
        await file.CopyToAsync(stream);

        return Ok(new { url = $"/uploads/{name}" });
    }
}

Check the content type on the server. The editor will insert whatever URL you return.

When you need a hook, not a new editor

Each instance is on window.__rte by its id (rte_ plus the property name). rte-onchange and rte-onready name global functions:

<rich-text-editor asp-for="Body" rte-onchange="onBodyChange" rte-onready="onEditorReady" />
<p id="words"></p>

<script>
  function onEditorReady(quill) { quill.focus(); }

  function onBodyChange(html, quill) {
    const words = quill.getText().trim().split(/\s+/).filter(Boolean).length;
    document.getElementById("words").textContent = words + " words";
  }
</script>

Optional modules stay off until you point at them:

rte-mention-url for @ lookups
rte-ai-url for a rewrite endpoint
rte-collab-url plus app.MapHub<RichTextHub>("/hubs/rte") for a SignalR broadcast

Snippets (heading, quote, code block) ship with IRichTextSnippetProvider. Replace that service if / should insert your own blocks.

Blazor

The same package exposes a component. Render the assets from the host page, map MapRazorRichTextAssets(), and bind a string:

<RichTextEditor @bind-Value="article.Body"
                Preset="ToolbarPreset.Blog"
                Appearance="EditorAppearance.Themed"
                Height="360"
                Placeholder="Start typing…" />

ValueChanged fires with the HTML string, same as the MVC hidden field.

Three mistakes that waste an afternoon

The tag helper is unknown. _ViewImports.cshtml is missing @addTagHelper *, RazorRichText.

CS0103: The name 'Blog' does not exist. The view is missing @using RazorRichText.Models. Attribute strings such as rte-preset="Blog" do not need the using; C# expressions such as rte-preset="@ToolbarPreset.Blog" do.

The editor area is blank and the console says Quill is not loaded. MapRazorRichTextAssets() was never called, or RenderRichTextAssets() is not in the layout. Embedded files are served from /_razor-rich-text only after that map.

What you stop maintaining

You stop copying Quill boilerplate between projects, writing a sanitiser allow-list, and special-casing the empty-editor HTML in every view model. One package, one tag, and the POST payload is HTML you can store.

Source and license: github.com/StevenKamwaza/RazorRichText (MIT).

[Boost]

Steven Kamwaza — Tue, 15 Sep 2026 08:40:38 +0000

Steven Kamwaza

Sep 15

Twinify 1.1.0: Map Without Profiles, Hide Secrets With Attributes, and Ship Native AOT

#dotnet #twinify #csharp #webdev

3 min read

Twinify 1.1.0: Map Without Profiles, Hide Secrets With Attributes, and Ship Native AOT

Steven Kamwaza — Tue, 15 Sep 2026 05:11:32 +0000

If you missed the earlier posts on Twinify: Twinify is a MIT-licensed object mapper for .NET 8, 9, and 10. You call mapper.Map<UserDto>(user) and it copies matching members. Profiles still exist when names are not enough.

1.0.2 was about speed. 1.1.0 is about less boilerplate, safer DTOs, and Native AOT.

dotnet add package Twinify
dotnet add package Twinify.DependencyInjection

NuGet: Twinify

The idea

You still inject IMapper and you still call Map. Existing profile-only apps keep the same behaviour. Everything below is additive.

1. Mapping without a profile

Matching names used to still need CreateMap. Not anymore.

builder.Services.AddTwinify();

public class UserService(IMapper mapper)
{
    public UserDto ToDto(User user) => mapper.Map<UserDto>(user);
}

No CreateMap. Twinify copies same-name members, flattens Address.City → AddressCity, and walks nested objects and collections.

No DI? Same thing:

var mapper = new Mapper();
var dto = mapper.Map<UserDto>(user);

2. Keep your profiles. Auto-map the rest.

Registering a profile is still classic Twinify: only declared top-level pairs map.

Want both? One flag:

builder.Services.AddTwinify(cfg => cfg.AddProfile<UserProfile>())
    .AllowMappingWithoutProfiles();

CreateMap always wins for that pair. Nested types inside an explicit map still auto-map — you do not need CreateMap<Address, AddressDto>() just because User has an Address.

3. Attributes instead of another `ForMember`

Hide secrets

public class UserDto
{
    public int Id { get; set; }
    public string Name { get; set; } = "";

    [IgnoreMap]
    public string? Password { get; set; }
}

Rename or flatten without a profile

public class UserDto
{
    [MapFrom("Address.City")]
    public string Town { get; set; } = "";
}

Pick a constructor when the destination has more than one: [MapConstructor].

Need to turn attributes off? UseMappingAttributes(false).

4. Native AOT: a source generator in the same package

JIT apps still compile maps at runtime. Native AOT cannot do that.

The Twinify package now ships Twinify.SourceGenerator. Mark the pair; Twinify emits a static, reflection-free map at compile time.

[Twinify(typeof(User))]
public class UserDto
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
}

Or at assembly scope:

[assembly: TwinifyMap(typeof(User), typeof(UserDto))]

Uncustomized CreateMap in a profile constructor can be generated too. Nested convention-compatible members of a generated pair are included.

Honest limitation: fluent ForMember / ConvertUsing are not generated. Prefer [MapFrom] / [IgnoreMap] on AOT, or keep those pairs on JIT. A pair with no generated map throws MappingNotFoundException on Native AOT.

That is the 1.0.2 “what’s next” item, shipped.

5. Records, in-place map, fail at boot

Records bind constructor parameters by name. Extra settable properties still copy after construction.

public record Person(int Id, string Name);
public record PersonDto(int Id, string Name);

var dto = mapper.Map<PersonDto>(new Person(1, "Ada"));

Update an existing instance:

mapper.Map(user, existingDto);

Catch bad maps at startup instead of on the first request:

builder.Services.AddTwinify(cfg => cfg.AddProfile<UserProfile>())
    .ValidateMappings();

Still stuck? mapper.Explain<User, UserDto>() shows where each destination member gets its value.

Upgrade path

You have	You do
Profile-only 1.0.x app	Update the package. Behaviour stays the same.
Tired of `CreateMap` for identical DTOs	`AllowMappingWithoutProfiles()` or drop profiles for those pairs.
Native AOT / trimming	Add `[Twinify]` or `[TwinifyMap]` and prefer attributes over fluent customizations.

IMapper and Map<TDestination>(source) did not change.

Try it

dotnet add package Twinify --version 1.1.0
dotnet add package Twinify.DependencyInjection --version 1.1.0

NuGet: https://www.nuget.org/packages/Twinify
Release notes: Twinify 1.1.0

If you map DTOs in ASP.NET Core, workers, or AOT apps, I would love a try, a star, or a comment about the pair that still feels too noisy.

Twinify — object mapping without the ceremony.

Twinify 1.0.2: A Look at the Latest Performance Improvements

Steven Kamwaza — Wed, 19 Aug 2026 06:15:59 +0000

Over the past few weeks, the performance and memory efficiency of Twinify has been improved, twinify is an open-source object-to-object mapping library for .NET.

The latest release, Twinify 1.0.2, brings some encouraging improvements compared with the initial 1.0.0 release.

I also wanted to keep the benchmarking honest, so the tests include AutoMapper 16.2.0 as a reference point.

Twinify is designed to make object mapping simple, while supporting common scenarios such as nested objects, collections, flattening, constructor mapping, and custom mappings.

The Benchmark

The benchmark uses:

.NET 10
BenchmarkDotNet 0.15.8
Windows 11
Intel Core i7-1355U
Twinify 1.0.0
Twinify 1.0.2
AutoMapper 16.2.0

The object graph being mapped is not just a simple flat object.

The benchmark maps:

User
 ├── Address
 └── Orders
      ├── Order
      │    └── OrderItems
      └── Order
           └── OrderItems

Two scenarios are tested:

Mapping a single User to UserDto
Mapping 1,000 users to UserDto

Memory allocation and GC activity are also measured using BenchmarkDotNet's MemoryDiagnoser.

Performance Progress

Here are the results.

Scenario	Metric	Twinify 1.0.0	Twinify 1.0.2	AutoMapper 16.2.0
Single User	Mean	3.819 μs	4.087 μs	1.066 μs
Single User	Allocated	3,304 B	1,848 B	848 B
1,000 Users	Mean	4,420.174 μs	2,420.444 μs	1,108.267 μs
1,000 Users	Allocated	3,320,120 B	1,864,120 B	864,120 B
1,000 Users	Gen0	523.4375	296.8750	136.7188
1,000 Users	Gen1	242.1875	171.8750	78.1250

45% Faster Bulk Mapping

The biggest improvement can be seen when mapping 1,000 users.

Twinify 1.0.0:

4,420.174 μs

Twinify 1.0.2:

2,420.444 μs

That's approximately a 45% reduction in execution time.

The performance gap with AutoMapper has also become much smaller.

AutoMapper 16.2.0 completes the same benchmark in:

1,108.267 μs

There is still a gap, but the improvement from the initial Twinify release is significant.

44% Less Memory Allocation

Performance isn't only about execution time.

For the 1,000-user benchmark:

Twinify 1.0.0
3,320,120 B

Twinify 1.0.2
1,864,120 B

That's approximately 44% less memory allocation.

This is particularly important for applications performing large numbers of mappings because unnecessary allocations can increase GC pressure.

Reduced GC Pressure

The reduction in allocations is also reflected in the GC measurements.

For the 1,000-user benchmark, Gen0 collections dropped from:

523.4375 → 296.8750

That's approximately a 43% reduction.

Gen1 also decreased:

242.1875 → 171.8750

or approximately 29%.

These improvements are encouraging because they show that the memory optimizations are not simply reflected in the allocation column; they are also reducing GC activity.

What About AutoMapper?

AutoMapper 16.2.0 is still ahead in this benchmark.

For 1,000 users:

Twinify 1.0.2   2,420.444 μs
AutoMapper      1,108.267 μs

And in allocations:

Twinify 1.0.2   1,864,120 B
AutoMapper        864,120 B

So there is still work to do.

What's Next?

The next optimization targets are clear.

I'm particularly interested in reducing:

Mapping execution overhead
Allocations during nested and collection mapping
Reflection or dynamic dispatch on the hot path
Temporary objects and collections
GC pressure during large mapping operations

The current results already show that there is plenty of room for optimization.

The next milestone is to continue closing the gap while keeping Twinify's API simple and predictable.

Why Benchmark?

One of the things I want to emphasize with Twinify is that performance claims should be backed by reproducible benchmarks.

Rather than simply saying that a mapper is "fast", I'm trying to track actual changes between releases.

For example:

Twinify 1.0.0
      ↓
4.42 ms / 1,000 users
      ↓
Twinify 1.0.2
      ↓
2.42 ms / 1,000 users

That gives future releases something concrete to improve against.

Try Twinify

Twinify is available on NuGet and the documentation contains examples covering profiles, nested mappings, collections, dependency injection, and other mapping scenarios.

Documentation:
Twinify Documentation

NuGet:
Twinify on NuGet

The current NuGet listing identifies 1.0.2 as the latest Twinify release.

Final Thoughts

Twinify 1.0.2 is another step forward.

The current benchmark shows:

🚀 45% faster bulk mapping compared with Twinify 1.0.0
💾 44% less memory allocation
♻️ 43% fewer Gen0 collections
📈 A significantly smaller performance gap compared with the initial release

There is still a lot of optimization ahead, and that's part of the fun.

I'm looking forward to seeing how far Twinify can go.

If you're interested in .NET object mapping, performance optimization, or open-source development, I'd love to hear your thoughts and feedback.

Twinify — Object Mapping Made Simple.

dotnet #csharp #opensource #performance

Getting Started with Twinify: A Free, Open-Source Object Mapper for Modern .NET

Steven Kamwaza — Fri, 24 Jul 2026 05:44:07 +0000

Lightweight. Familiar. MIT Licensed. Built for .NET 8, 9, and 10.

Following AutoMapper's recent licensing changes, many .NET developers have started looking for an open-source alternative that doesn't require rewriting years of mapping code.

That's one of the reasons I built Twinify.

Twinify is a lightweight, high-performance object-to-object mapper that provides a familiar fluent API, making it easy to map DTOs, entities, view models, records, and complex object graphs while remaining completely open source under the MIT License.

If you're already using AutoMapper, you'll find the transition straightforward for many common mapping scenarios.

Why Twinify?

✔ MIT Licensed

✔ Built for .NET 8, .NET 9 & .NET 10

✔ Familiar AutoMapper-style Fluent API

✔ Dependency Injection Support

✔ Automatic Convention-Based Mapping

✔ Nested Objects & Collections

✔ Flattening

✔ Record & Constructor Mapping

✔ Mapping Diagnostics with Explain<TSource, TDestination>()

Installation

Install the required packages.

dotnet add package Twinify
dotnet add package Twinify.DependencyInjection

Step 1 — Create a Mapping Profile

Define your mappings by inheriting from MappingProfile.

public class UserProfile : MappingProfile
{
    public UserProfile()
    {
        CreateMap<User, UserDto>()
            .ForMember(d => d.FullName,
                opt => opt.MapFrom(s => $"{s.FirstName} {s.LastName}"))
            .ForMember(d => d.Password,
                opt => opt.Ignore());
    }
}

Twinify uses a familiar fluent configuration model that should feel natural to developers coming from AutoMapper.

Step 2 — Register Twinify

builder.Services.AddTwinify(cfg =>
{
    cfg.AddProfile<UserProfile>();
});

Step 3 — Map Your Objects

Inject IMapper wherever it's needed.

public class UserService(IMapper mapper)
{
    public UserDto GetUser(User user)
    {
        return mapper.Map<UserDto>(user);
    }
}

That's all you need.

Twinify automatically maps properties with matching names while allowing full customization when required.

Features

Automatic Convention Mapping

Properties with identical names are mapped automatically.

User.Name
        ↓
UserDto.Name

No configuration required.

Automatic Flattening

Nested properties are flattened automatically.

Source

User.Address.City

↓

Destination

UserDto.AddressCity

Nested Object Mapping

Twinify recursively maps nested object graphs.

Order
 └── Customer
 └── Address
 └── Contacts

↓

OrderDto
 └── CustomerDto
 └── AddressDto
 └── ContactDtos

Collection Mapping

Supports:

Lists
Arrays
Dictionaries
Nested collections

Constructor & Record Mapping

Twinify automatically constructs destination types, including:

Immutable objects
Records
Parameterized constructors

Fluent Configuration

Twinify supports a rich configuration API, including:

CreateMap
ForMember
MapFrom
Ignore
Condition
ConvertUsing
BeforeMap
AfterMap
ReverseMap
IncludeBase
PreserveReferences

Explain Your Mappings

One feature that sets Twinify apart is mapping diagnostics.

mapper.Explain<User, UserDto>();

Instead of guessing why a property mapped the way it did, Explain() shows exactly where every destination member receives its value, making debugging significantly easier.

Migrating from AutoMapper

Many existing AutoMapper projects can migrate with only a few mechanical changes.

AutoMapper	Twinify
`Profile`	`MappingProfile`
`CreateMap()`	Same familiar API
`ForMember()`	Same familiar API
`MapFrom()`	Same familiar API
`ReverseMap()`	Supported
`AddAutoMapper()`	`AddTwinify()`
Custom resolvers	`ConvertUsing()` and member configuration

Migration Guide

1. Remove AutoMapper

dotnet remove package AutoMapper

2. Install Twinify

dotnet add package Twinify
dotnet add package Twinify.DependencyInjection

3. Update Your Profiles

Replace

public class UserProfile : Profile

with

public class UserProfile : MappingProfile

4. Update Dependency Injection

Replace

builder.Services.AddAutoMapper(...);

with

builder.Services.AddTwinify(cfg =>
{
    cfg.AddProfile<UserProfile>();
});

5. Build & Test

Many existing CreateMap() and ForMember() configurations should require little or no modification.

As with any migration, it's recommended to run your existing mapping tests to validate behavior.

Why I Built Twinify

I wanted a mapper that is:

Open source
Lightweight
Easy to understand
Familiar to existing AutoMapper users
Built specifically for modern .NET

Rather than forcing developers to learn an entirely new API, Twinify focuses on keeping the transition intuitive while continuing to evolve with community feedback.

Getting Started

📦 NuGet

dotnet add package Twinify

📖 Documentation

https://github.com/StevenKamwaza/Twinify.Docs

💻 Source Code

https://github.com/StevenKamwaza/Twinify

⭐ If Twinify helps your project, consider giving the repository a star and sharing your feedback. Community contributions and feature requests are always welcome.

Happy Coding! 🚀

Built with ❤️ for the .NET community.

Share Your Thoughts

Have questions, feature ideas, or migration feedback?

Open an issue or start a discussion on GitHub—I'd love to hear how you're using Twinify in your projects.

Trending Hashtags

dotnet #csharp #dotnet8 #dotnet9 #dotnet10 #opensource #nuget #softwareengineering #backend #webdevelopment #cleanarchitecture #developer #coding #programming #github #aspnetcore #entityframework #architecture #productivity #developers #devcommunity #100DaysOfCode #BuildInPublic #OSS #AutoMapper #Twinify

DEV Community: Steven Kamwaza

Stop Wiring Quill by Hand: RazorRichText for ASP.NET Core

Wire it once

A model that understands HTML

Pick a preset instead of a button list

Show the saved article

Drafts and images

When you need a hook, not a new editor

Blazor

Three mistakes that waste an afternoon

What you stop maintaining

[Boost]

Twinify 1.1.0: Map Without Profiles, Hide Secrets With Attributes, and Ship Native AOT

Twinify 1.1.0: Map Without Profiles, Hide Secrets With Attributes, and Ship Native AOT

The idea

1. Mapping without a profile

2. Keep your profiles. Auto-map the rest.

3. Attributes instead of another ForMember

4. Native AOT: a source generator in the same package

5. Records, in-place map, fail at boot

Upgrade path

Try it

Twinify 1.0.2: A Look at the Latest Performance Improvements

The Benchmark

Performance Progress

45% Faster Bulk Mapping

44% Less Memory Allocation

Reduced GC Pressure

What About AutoMapper?

What's Next?

Why Benchmark?

Try Twinify

Final Thoughts

dotnet #csharp #opensource #performance

Getting Started with Twinify: A Free, Open-Source Object Mapper for Modern .NET

Why Twinify?

Installation

Step 1 — Create a Mapping Profile

Step 2 — Register Twinify

Step 3 — Map Your Objects

Features

Automatic Convention Mapping

Automatic Flattening

Nested Object Mapping

Collection Mapping

Constructor & Record Mapping

Fluent Configuration

Explain Your Mappings

Migrating from AutoMapper

Migration Guide

1. Remove AutoMapper

2. Install Twinify

3. Update Your Profiles

4. Update Dependency Injection

5. Build & Test

Why I Built Twinify

Getting Started

Happy Coding! 🚀

Share Your Thoughts

Trending Hashtags

3. Attributes instead of another `ForMember`