<?xml version="1.0" encoding="utf-8"?>
<rss xmlns:a10="http://www.w3.org/2005/Atom" version="2.0">
  <channel xmlns:media="http://search.yahoo.com/mrss/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <title>ABP.IO Stories</title>
    <link>https://abp.io/community/articles</link>
    <description>A hub for ABP Framework, .NET, and software development. Access articles, tutorials, news, and contribute to the ABP community.</description>
    <lastBuildDate>Fri, 20 Nov 2026 09:38:15 Z</lastBuildDate>
    <generator>Community - ABP.IO</generator>
    <image>
      <url>https://abp.io/assets/favicon.ico/favicon-32x32.png</url>
      <title>ABP.IO Stories</title>
      <link>https://abp.io/community/articles</link>
    </image>
    <a10:link rel="self" type="application/rss+xml" title="self" href="https://abp.io/community/rss?member=dignite" />
    <item>
      <guid isPermaLink="true">https://abp.io/community/posts/notifications-a-module-for-abp-a-notification-pipeline-cut-at-the-distributed-event-bus-ns8yxcag</guid>
      <link>https://abp.io/community/posts/notifications-a-module-for-abp-a-notification-pipeline-cut-at-the-distributed-event-bus-ns8yxcag</link>
      <a10:author>
        <a10:name>dignite</a10:name>
        <a10:uri>https://abp.io/community/members/dignite</a10:uri>
      </a10:author>
      <category>real-time-notifications</category>
      <category>app-notifications</category>
      <title>Notifications, a Module for ABP: A Notification Pipeline Cut at the Distributed Event Bus</title>
      <description>Dignite Notifications, an open-source ABP module, cuts the notification pipeline at the distributed event bus: the inbox row is the record, and SignalR, email and app push are event handlers that deliver wherever they are installed. The design, the code and the costs.</description>
      <pubDate>Fri, 20 Nov 2026 07:48:08 Z</pubDate>
      <a10:updated>2026-11-20T08:20:42Z</a10:updated>
      <content:encoded><![CDATA[<h1>Notifications, a Module for ABP: A Notification Pipeline Cut at the Distributed Event Bus</h1>
<p>Dignite Notifications is an open-source module (LGPL-3.0) built on ABP Framework. Business code publishes a notification; the module decides who receives it, keeps a record of it, and gets it to people through SignalR, email or a push to their phone's app. The optional Notification Center adds a persistent inbox, subscriptions and read state, stored with EF Core or MongoDB, with an MVC and an Angular UI. The module can run inside a business system's own process, or be deployed as a notification service of its own.</p>
<p>The hardest part of a notification module to design is where to cut the pipeline: choosing the recipients, keeping the record and delivering through each channel - which of these belong together, and which apart. This article shows where this module cuts it, and how the cut is implemented. It assumes a few ABP basics: modules and dependency injection, the distributed event bus (with its outbox and inbox), and background jobs.</p>
<h2>The Problem</h2>
<p>A notification has three things to do:</p>
<ol>
<li><strong>Decide who receives it</strong>: the users named explicitly, or those subscribed to it, filtered by permissions and features.</li>
<li><strong>Keep a record</strong>: one inbox row per recipient, read or unread.</li>
<li><strong>Reach the person</strong>: a real-time message in the browser, an email, a push to the app on their phone.</li>
</ol>
<p>A common implementation does all three in one call. ASP.NET Boilerplate, the framework ABP grew out of, is an example: its distribution job resolves the recipients, writes a row for each of them, and then, in the same method, calls each configured notifier in turn; a publisher can also name the notifiers a notification should use, by the notifier's type name.</p>
<p>Binding the three together fails where they differ:</p>
<ul>
<li><strong>They live in different places.</strong> The record belongs with the inbox's database; a channel belongs with its SDK and its credentials. One call means one process: putting push in another service, or letting a business microservice publish without hosting the inbox, is not possible.</li>
<li><strong>They fail differently.</strong> An inbox row is written or rolled back. An email provider timing out or a push service throttling is the channel's own problem: the record should not fail with it, and should not wait for it in the same transaction.</li>
<li><strong>They are decided by different parties.</strong> Who receives a notification is the business's decision; which channels carry it is the host's: a reusable module does not know which channels the host installed. Naming channels at publish time hands that decision to the party that knows least.</li>
</ul>
<h2>The Idea: The Record Is Authoritative, Delivery Is an Event</h2>
<p>The cut is made at ABP's distributed event bus.</p>
<p>The distributor does the first two things: it settles the recipients and writes their inbox rows. It does not do the third. Instead, it publishes one <code>NotificationDeliveryRequestedEto</code> for each recipient and channel. Each channel is a handler of that event, and delivers in whichever process it is installed in.</p>
<p>The two sides are not equal: <strong>the inbox row is authoritative; channel delivery is best-effort.</strong> A real-time message is only a prompt, after which the UI refreshes from the REST API; an email that could not be sent leaves the notification in the inbox.</p>
<p>There is a matching cut before distribution: publishing can be an event too. A process that publishes but does not distribute hands the whole notification over as one <code>NotificationPublishRequestedEto</code>, and the process that hosts the inbox distributes it.</p>
<p><img src="https://raw.githubusercontent.com/dignite-projects/abp-modules/main/docs/en/articles/2026-07-16-introducing-abp-notification-center/images/pipeline.png" alt="The two cuts in the notification pipeline" /></p>
<p><em>The path of one notification. Both cuts are distributed events: the publish request before distribution, the delivery requests after it.</em></p>
<p>With the pipeline cut there, several things follow:</p>
<ul>
<li><strong>Channels are plug-ins.</strong> A notifier depends only on the contracts package <code>Dignite.Abp.Notifications.Abstractions</code> and its own SDK; the pipeline knows no channel names. Adding a channel changes neither the pipeline nor the channels existing notifications take.</li>
<li><strong>The inbox is optional.</strong> Without the Notification Center, the store is one that does nothing, and the pipeline still publishes the delivery events: an application that only needs real-time alerts needs no notification tables.</li>
<li><strong>The record and the delivery can commit together.</strong> The inbox rows and the delivery events are written in the distribution's unit of work; with ABP's transactional outbox, they commit or roll back together.</li>
<li><strong>The process boundary is a deployment choice.</strong> A channel in another process is a matter of where its handler is installed; a publisher in another process is a matter of one more event. Business code only ever calls <code>INotificationPublisher</code>.</li>
<li><strong>The payload crosses every boundary unchanged.</strong> It is serialized once, at publish time, tagged with a stable type name, and travels as the same string through the database, the events, another process and the front end.</li>
</ul>
<h2>The Implementation</h2>
<h3>One Batch of Recipients: The Record First, Then the Events</h3>
<p><code>DefaultNotificationDistributor</code> processes recipients in batches (an explicit list in chunks, subscribers in keyset pages), and each batch is the cut described above:</p>
<pre><code class="language-csharp">// A definition's permission and feature requirements apply to explicit recipients and
// subscribers alike: passing userIds does not bypass authorization
var eligible = new List&lt;Guid&gt;(candidates.Count);
foreach (var userId in candidates)
{
    if (await DefinitionManager.IsAvailableAsync(notification.NotificationName, userId))
    {
        eligible.Add(userId);
    }
}

// The record: the notification once, one inbox row per recipient
if (!state.NotificationInserted)
{
    await Store.InsertNotificationAsync(notification, cancellationToken);
    state.NotificationInserted = true;
}
await Store.InsertUserNotificationsAsync(inboxRows, cancellationToken);

// The delivery: one distributed event per recipient and channel
foreach (var userId in eligible)
{
    foreach (var channel in channels)
    {
        await DistributedEventBus.PublishAsync(CreateDeliveryRequest(notification, userId, channel));
    }
}
</code></pre>
<p>The distributor calls no notifier. The channels it knows are a few strings from the routing rules (below), resolved once per notification, not per recipient.</p>
<p>A small explicit list of recipients is distributed inline, in the publisher's request; a notification resolved from subscriptions, or with more recipients than a threshold, goes to a background job. <code>NotificationDistributionDispatcher</code> makes that choice, for local and remote publishing alike, so both paths have the same bounds.</p>
<h3>The Delivery Event Is a Flat Wire Contract</h3>
<pre><code class="language-csharp">[EventName(&quot;Dignite.Abp.Notifications.NotificationDeliveryRequested&quot;)]
public class NotificationDeliveryRequestedEto : IEventDataMayHaveTenantId
{
    public Guid NotificationId { get; set; }
    public string NotificationName { get; set; }
    public string? DataJson { get; set; }   // {&quot;type&quot;:&quot;Shop.OrderShipped&quot;, ...}
    public NotificationSeverity Severity { get; set; }
    public DateTime CreationTime { get; set; }
    public Guid UserId { get; set; }
    public string Channel { get; set; }
    public string? EntityTypeName { get; set; }
    public string? EntityId { get; set; }
    public Guid? TenantId { get; set; }
}
</code></pre>
<p>One event is one tenant, one notification, one recipient and one channel. The payload is not a polymorphic object but a JSON string serialized in advance, for two reasons:</p>
<ul>
<li>ABP's event bus (with its outbox and inbox) serializes events with the default System.Text.Json options, not the application's own, and a polymorphic property does not survive that.</li>
<li>The process that receives the event may not have the payload's .NET type. The distributor copies the string from the publish into the event; it never serializes it again.</li>
</ul>
<p>The type name in the string comes from an attribute on the payload class. It is a stable name, not a .NET type name:</p>
<pre><code class="language-csharp">[NotificationDataType(&quot;Shop.OrderShipped&quot;)]
public class OrderShippedNotificationData : NotificationData
{
    public string OrderNumber { get; set; } = default!;
}
</code></pre>
<p>Renaming an assembly or moving a type leaves the stored JSON and the events in flight readable. The same string is the front end's key: the Angular UI registers a component to render each payload type by it, and a link to follow for each <code>EntityTypeName</code>, without knowing any .NET type.</p>
<h3>A Channel Handles Only the One It Hosts</h3>
<p>Every process with the implementation package receives the delivery events of every channel. <code>NotificationDeliveryRequestedHandler</code> resolves only the notifier registered for the event's channel:</p>
<pre><code class="language-csharp">public virtual async Task HandleEventAsync(NotificationDeliveryRequestedEto eventData)
{
    var notifier = ResolveNotifierOrNull(eventData.Channel);
    if (notifier == null)
    {
        // This process does not host the channel: normal in a split deployment,
        // left to the process that does
        return;
    }

    try
    {
        await notifier.DeliverAsync(eventData, cancellationToken);
    }
    catch (Exception exception)
    {
        // Best-effort: logged and dropped, never thrown back into the event bus, never retried
        Logger.LogWarning(/* the notification id, the channel and the exception type only */);
    }
}
</code></pre>
<p>These few lines set a channel's boundaries:</p>
<ul>
<li>An email delivery never builds the push or SignalR notifier, and one channel failing to build does not affect the others.</li>
<li>A failed delivery is not thrown back into the event bus, where it would surface in the publisher's unit of work or be redelivered by an inbox again and again.</li>
<li>Not hosting a channel is legitimate. When a routing rule names a channel the process does not host, startup logs a warning by default; <code>RequireHostedChannels</code> turns it into a startup failure.</li>
</ul>
<p>A channel's whole contract is <code>INotificationNotifier</code>: a stable <code>Name</code> and a <code>DeliverAsync</code>.</p>
<h3>Three Channels: SignalR, Email and App Push</h3>
<p>The module ships three channels, each one an implementation of that contract that depends only on Abstractions and its own SDK. They start from the same delivery event and have entirely different problems to solve, which is the best argument for putting channels after the event: the distributor needs to know none of those problems.</p>
<p><strong>SignalR</strong> is the simplest. <code>SignalRNotifier</code> turns the event into a flat <code>SignalRNotificationMessage</code> and sends it to every connection of the user:</p>
<pre><code class="language-csharp">await HubContext.Clients.User(request.UserId.ToString()).SendCoreAsync(
    nameof(INotificationsClient.ReceiveNotification),
    new object[] { SignalRNotificationMessage.FromRequest(request) },
    cancellationToken);
</code></pre>
<p>The payload in the message is the JSON object as it was published, the same shape the REST inbox returns; the message carries no list of recipients, so a user never sees another user's id. The UI treats it as a prompt and refreshes the unread count and the list from the REST API.</p>
<p><strong>Email</strong> has two more questions to answer: what the user's address is, and what the email for this notification says. Each is an extensible chain: <code>IEmailNotificationAddressResolver</code> resolves the address and the language (from the ABP Identity account, with <code>Emailing.Identity</code> installed), and <code>INotificationEmailContentProvider</code> builds the subject and the body by payload type. The body is built in the recipient's language, and the current culture is restored right after.</p>
<p><strong>App push</strong> is hard outside the sending: a user has several phones, the app reports their tokens, tokens rotate and die, and people sign in to a different account on the same phone. <code>PushNotifier</code> delivers in four steps:</p>
<ol>
<li>Get the user's registered devices from <code>IPushDeviceStore</code>.</li>
<li>Group them by language, and build the text once <strong>per language</strong>, not once per device.</li>
<li>Group them by the <strong>push provider</strong> recorded on each device, and send through the matching <code>IPushProvider</code>.</li>
<li>Remove the tokens the provider reports as no longer registered.</li>
</ol>
<p>There is one channel, <code>Push</code>. Expo, FCM and APNs are providers under it, chosen per device, so a routing rule only ever names <code>Push</code>. The module ships the Expo provider, one API for both iOS and Android:</p>
<pre><code class="language-csharp">public interface IPushProvider
{
    string Name { get; }   // &quot;Expo&quot;, matched against the provider on each device registration
    Task&lt;IReadOnlyList&lt;PushSendResult&gt;&gt; SendAsync(
        IReadOnlyList&lt;PushMessage&gt; messages, CancellationToken cancellationToken = default);
}
</code></pre>
<p>The text of a push comes from a chain of content providers, as an email's does:</p>
<pre><code class="language-csharp">public class OrderShippedPushContentProvider
    : NotificationPushContentProvider&lt;OrderShippedNotificationData&gt;, ITransientDependency
{
    private readonly IStringLocalizer&lt;ShopResource&gt; _localizer;

    public OrderShippedPushContentProvider(IStringLocalizer&lt;ShopResource&gt; localizer)
    {
        _localizer = localizer;
    }

    protected override Task&lt;NotificationPushContent?&gt; BuildOrNullAsync(
        NotificationPushBuildContext context,
        OrderShippedNotificationData data,
        CancellationToken cancellationToken)
    {
        return Task.FromResult&lt;NotificationPushContent?&gt;(new NotificationPushContent(
            title: _localizer[&quot;Push:OrderShipped:Title&quot;],
            body: _localizer[&quot;Push:OrderShipped:Body&quot;, data.OrderNumber]));
    }
}
</code></pre>
<p>The silent data of a push holds four keys only, <code>notificationId</code>, <code>notificationName</code>, <code>entityTypeName</code> and <code>entityId</code>, never the payload. A push is capped at about 4 KB and passes through Apple's, Google's and the provider's servers; when the push is tapped, the app opens the matching inbox entry by <code>notificationId</code> and marks it read, and fetches the full notification from the Notification Center's API. Here too a push is only a prompt, and the inbox row is the record.</p>
<p>Devices are registered in the Notification Center: a <code>PushDevice</code> aggregate, and two endpoints:</p>
<pre><code>POST /api/notification-center/push-devices/register     { &quot;provider&quot;: &quot;Expo&quot;, &quot;token&quot;: &quot;...&quot; }
POST /api/notification-center/push-devices/unregister   { &quot;provider&quot;: &quot;Expo&quot;, &quot;token&quot;: &quot;...&quot; }
</code></pre>
<p>The app registers on every launch, after sign-in and when the user changes its language, and unregisters at sign-out. The device's language is the culture of the registering request; the token travels only in the request body, never in a URL or a log. A token is unique across all tenants: one already registered to another user moves to the caller, so a phone gets the pushes of whoever signed in on it last. Each user has a cap on devices, and the one not reported for the longest time makes way for a new one.</p>
<p><code>Dignite.NotificationCenter.Push</code> is a bridge package that implements <code>IPushDeviceStore</code> over this registry; an application without the Notification Center implements the interface itself. With <code>Dignite.NotificationCenter.Push.Identity</code> installed as well, push follows the ABP login session:</p>
<pre><code class="language-csharp">// A device keeps the session id it was registered under; a device whose session no longer
// exists is not pushed to, and is removed from the registry
var liveSessionIds = (await SessionRepository.GetListAsync(userId: userId, cancellationToken: cancellationToken))
    .Select(session =&gt; session.SessionId)
    .ToHashSet(StringComparer.Ordinal);

return devices
    .Where(device =&gt; device.SessionId != null &amp;&amp; !liveSessionIds.Contains(device.SessionId))
    .ToList();
</code></pre>
<p>Once the user signs out, an administrator revokes the session, the concurrent login rule ends it or it is cleaned up as inactive, the phone receives no more pushes, even when the app never got to call unregister.</p>
<p>For business code, sending a notification to the app is one more channel name in a routing rule.</p>
<h3>The Host Decides the Channels, Last</h3>
<p>Channels are not a property of the notification's definition, and are not passed at publish time. They are configured in <code>NotificationRoutingOptions</code>:</p>
<pre><code class="language-csharp">// A business module: defaults for its own notifications
Configure&lt;NotificationRoutingOptions&gt;(options =&gt;
    options.ForNotification(&quot;Shop.OrderShipped&quot;, SignalRNotifier.ChannelName));

// The host module: configured last, overrides any of them or sets the fallback
Configure&lt;NotificationRoutingOptions&gt;(options =&gt;
{
    options.ForNotification(&quot;Shop.OrderShipped&quot;, SignalRNotifier.ChannelName, PushNotifier.ChannelName);
    options.InboxOnly(&quot;Shop.WeeklyDigest&quot;);
});
</code></pre>
<p>This is plain ABP options semantics: what is configured later replaces what was configured earlier, and the host module is configured last, so the host has the final word. There are only two levels of rules, one by notification name and the fallback <code>Default</code>. A notification no rule matches goes to the inbox only, and <code>Default</code> is never &quot;every registered channel&quot;, so installing a new channel does not quietly send existing notifications through it. A host that needs a dynamic decision, by tenant or by severity, replaces <code>INotificationChannelResolver</code>.</p>
<h3>The Inbox Is a Store That Can Be Empty</h3>
<p>The distributor depends only on <code>INotificationStore</code>. The contract and its empty implementation are both in Abstractions:</p>
<pre><code class="language-csharp">[Dependency(TryRegister = true)]
public class NullNotificationStore : INotificationStore, ISingletonDependency
</code></pre>
<p><code>TryRegister</code> lets any store registered first win, so installing the Notification Center replaces it, and neither the pipeline nor the publishing API changes. Without an inbox one more rule has to hold: a notification with no channel could go nowhere. The distributor throws on one, and startup checks the routing for it first.</p>
<h3>Publishing Can Be an Event Too</h3>
<p>A process that publishes but does not distribute installs <code>Dignite.Abp.Notifications.Client</code>, whose <code>RemoteNotificationPublisher</code> implements the same <code>INotificationPublisher</code>. What only the publisher knows is settled in the publisher:</p>
<ul>
<li>The notification name must be defined locally; an undefined name throws while the caller is still waiting.</li>
<li>The payload is serialized here, so the receiver needs no payload type.</li>
<li>The channels are resolved here, because the business module's routing defaults are configured in this process.</li>
<li>Finally one <code>NotificationPublishRequestedEto</code> is published. Within a unit of work, it goes into the publisher's own outbox, in the same transaction as the business change.</li>
</ul>
<p>One notification is one event, whatever the number of recipients. The process that hosts the inbox receives it with <code>NotificationPublishRequestedHandler</code> and hands it to the same local dispatcher, from where the path is exactly that of a local publish. The notification id the publisher generated becomes the id in the inbox, so it is also the idempotency key: ABP's event inbox deduplicates by message id, and the store's check on the notification id is a second guard.</p>
<p>The receiver also needs the publishers' notification definitions: the inbox groups and names notifications by them, and the permission and feature requirements are part of them. This follows ABP's permission management: every publisher saves its static definitions to a shared definition store at startup, and the receiver reads them dynamically. A notification name the receiver cannot find is refused with an exception instead of being distributed, so the event inbox retries it later, because a missing definition would mean missing requirements.</p>
<p>The same business code is deployed three ways, differing only in the packages installed:</p>
<pre><code class="language-csharp">// A monolith: publishing, distribution, the inbox and the channels in one process
[DependsOn(
    typeof(AbpNotificationCenterApplicationModule),   // brings AbpNotificationsModule
    typeof(AbpNotificationCenterEntityFrameworkCoreModule),
    typeof(AbpNotificationsSignalRModule))]

// A business service: publishes only
[DependsOn(
    typeof(AbpNotificationsClientModule),
    typeof(AbpNotificationsEntityFrameworkCoreModule))]  // saves its definitions to the shared store

// The notification service: distribution, the inbox and the channels
[DependsOn(
    typeof(AbpNotificationCenterApplicationModule),
    typeof(AbpNotificationCenterEntityFrameworkCoreModule),
    typeof(AbpNotificationsEntityFrameworkCoreModule),
    typeof(AbpNotificationsSignalRModule),
    typeof(AbpNotificationsEmailingModule),
    typeof(AbpNotificationsPushExpoModule),
    typeof(AbpNotificationCenterPushModule))]
// with NotificationDefinitionStoreOptions.IsDynamicNotificationStoreEnabled on, to read the publishers' definitions
</code></pre>
<p>A business module's own module class depends only on <code>AbpNotificationsAbstractionsModule</code>, and the host chooses which of these it is.</p>
<p><img src="https://raw.githubusercontent.com/dignite-projects/abp-modules/main/docs/en/articles/2026-07-16-introducing-abp-notification-center/images/deployments.png" alt="In one process or split" /></p>
<p><em>The same business code, in one process or split across services.</em></p>
<h2>The Costs</h2>
<ul>
<li><strong>Channel delivery has no guarantee.</strong> There is no per-recipient delivery record, no lease and no retry; no setup guarantees that an external channel delivers exactly once. A channel that needs reliable delivery, such as SMS, has to retry in its own notifier.</li>
<li><strong>Atomicity has preconditions.</strong> The inbox rows and the delivery events commit together only with the outbox and a transactional unit of work; MongoDB also needs a replica set. Without the outbox, a crash can leave a notification in the inbox that no channel delivered.</li>
<li><strong>Events multiply by recipients and channels.</strong> A thousand recipients on two channels are two thousand events. Batches and background jobs bound each step, but the load on the event bus is real.</li>
<li><strong>A split deployment needs a shared definition store.</strong> A publisher's definitions are saved when it starts, and the receiver reads them within about thirty seconds; a notification that arrives in between is retried by the inbox.</li>
<li><strong>App push ships one provider, Expo.</strong> Sending through FCM or APNs directly takes an <code>IPushProvider</code> of your own. Expo's receipts are not polled, so a device whose app was uninstalled often stays registered until the device cap or the end of its session removes it; and following the session needs an application that keeps ABP login sessions (the session management of ABP's Identity Pro), or devices carry no session and that layer does nothing.</li>
<li><strong>The publisher decides the channels.</strong> A remotely published notification arrives with its channels resolved, and the notification service does not route it again by its own rules. The routing defaults are written in the business modules, which only the publisher's process has.</li>
</ul>
<h2>Conclusion</h2>
<p>The design comes down to one step: cut the notification pipeline at the distributed event bus, with the inbox row as the record and channel delivery as an event. The distributor only settles the recipients and writes the record; a channel is an event handler, and delivers wherever it is installed. Pluggable channels (a push to a phone's app, with its whole device lifecycle, among them), an optional inbox, the record and the delivery committing together, and remote processes that only publish all follow from that step.</p>
<p>Its precondition is a distributed event bus with an outbox and an inbox, with one programming model in process and across processes. ABP's is one: in a monolith it dispatches in process, and after a split it is replaced by RabbitMQ or another implementation, with no change to business code or notifiers.</p>
<h2>Source Code and Documentation</h2>
<ul>
<li><a href="https://github.com/dignite-projects/abp-modules/tree/main/notifications">Source code</a></li>
<li><a href="https://github.com/dignite-projects/abp-modules/blob/main/docs/en/notifications/index.md">Documentation</a></li>
<li><a href="https://abp.io/docs/latest/framework/infrastructure/event-bus/distributed">ABP Distributed Event Bus</a></li>
</ul>
]]></content:encoded>
      <media:thumbnail url="https://abp.io/api/posts/cover-picture-source/3a250a1a-2dba-9dcd-2b8f-ad51f6fa8d59" />
      <media:content url="https://abp.io/api/posts/cover-picture-source/3a250a1a-2dba-9dcd-2b8f-ad51f6fa8d59" medium="image" />
    </item>
    <item>
      <guid isPermaLink="true">https://abp.io/community/posts/antiforgery-token-validation-when-angular-and-http-api-runs-on-the-same-server-mzf5ppdq</guid>
      <link>https://abp.io/community/posts/antiforgery-token-validation-when-angular-and-http-api-runs-on-the-same-server-mzf5ppdq</link>
      <a10:author>
        <a10:name>dignite</a10:name>
        <a10:uri>https://abp.io/community/members/dignite</a10:uri>
      </a10:author>
      <category>angular</category>
      <title>Antiforgery Token Validation When Angular and HTTP API Runs on the Same Server</title>
      <description>In this post, I explain how to overcome AntiForgery Token validation for HTTP requests in the ABP Angular project. This issue happens when the Angular and HTTP API projects are running on the same domain.  See the simple solution in this post.</description>
      <pubDate>Wed, 12 Jun 2024 01:10:39 Z</pubDate>
      <a10:updated>2026-04-16T04:38:15Z</a10:updated>
      <content:encoded><![CDATA[In this post, I explain how to overcome AntiForgery Token validation for HTTP requests in the ABP Angular project. This issue happens when the Angular and HTTP API projects are running on the same domain.  See the simple solution in this post.<br \><a href="https://dignite.com/blog/2024/01/Abp-Angular-and-Abp-API-Co-deployment" rel="nofollow noopener noreferrer" title="Go to the Post">Go to the Post</a>]]></content:encoded>
      <media:thumbnail url="https://abp.io/api/posts/cover-picture-source/3a131c2c-1228-c777-2c71-c9d8d632de4d" />
      <media:content url="https://abp.io/api/posts/cover-picture-source/3a131c2c-1228-c777-2c71-c9d8d632de4d" medium="image" />
    </item>
    <item>
      <guid isPermaLink="true">https://abp.io/community/posts/abphuremuwakunomerupei-xin-smtpclientkaramailkithenosumuzunaqie-riti-e-v99ssv8i</guid>
      <link>https://abp.io/community/posts/abphuremuwakunomerupei-xin-smtpclientkaramailkithenosumuzunaqie-riti-e-v99ssv8i</link>
      <a10:author>
        <a10:name>dignite</a10:name>
        <a10:uri>https://abp.io/community/members/dignite</a10:uri>
      </a10:author>
      <title>Abpフレームワークのメール配信：SmtpClientからMailKitへのスムーズな切り替え</title>
      <description>したがって、SmtpClientを使用してメールを送信する際に解決できない問題が発生した場合、MailKitに切り替えることは有効な解決策です。
例外メッセージは次のとおりです：System.Net.Mail.SmtpException:“Syntax error, command unrecognized. The server response was: ”。
Abpの公式デモを使用してテストを行った結果、同じメール設定情報を使用してMailKitのMailKitSmtpEmailSenderに切り替えるとメールの送信に成功しました。</description>
      <pubDate>Thu, 11 Jan 2024 08:15:34 Z</pubDate>
      <a10:updated>2026-04-22T08:50:34Z</a10:updated>
      <content:encoded><![CDATA[したがって、SmtpClientを使用してメールを送信する際に解決できない問題が発生した場合、MailKitに切り替えることは有効な解決策です。
例外メッセージは次のとおりです：System.Net.Mail.SmtpException:“Syntax error, command unrecognized. The server response was: ”。
Abpの公式デモを使用してテストを行った結果、同じメール設定情報を使用してMailKitのMailKitSmtpEmailSenderに切り替えるとメールの送信に成功しました。<br \><a href="https://dignite.com/jp/blog/2024/01/abp-framework-smtp-mailkit-transition" rel="nofollow noopener noreferrer" title="Go to the Post">Go to the Post</a>]]></content:encoded>
      <media:thumbnail url="https://abp.io/api/posts/cover-picture-source/3a1009c4-1c3c-f6fc-94e1-dc309eb1435d" />
      <media:content url="https://abp.io/api/posts/cover-picture-source/3a1009c4-1c3c-f6fc-94e1-dc309eb1435d" medium="image" />
    </item>
  </channel>
</rss>