Unobtrusive sample for .NET 10

samples/unobtrusive/Core_10/Client/Client.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+     <LangVersion>preview</LangVersion>
+    <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+      <PackageReference Include="NServiceBus" Version="10.0.0-alpha.1" />
+     <PackageReference Include="NServiceBus.Extensions.Hosting" Version="4.0.0-alpha.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\ConventionExtensions.cs" />
+  </ItemGroup>
+
+</Project>

samples/unobtrusive/Core_10/Client/CommandSender.cs

@@ -0,0 +1,86 @@
+using Commands;
+using Messages;
+
+public class CommandSender
+{
+    public static async Task Start(IMessageSession messageSession)
+    {
+        Console.WriteLine("Press 'C' to send a command");
+        Console.WriteLine("Press 'R' to send a request");
+        Console.WriteLine("Press 'D' to send a large message that is marked to be sent using data bus");
+        Console.WriteLine("Press 'X' to send a message that is marked with expiration time.");
+        Console.WriteLine("Press any other key to exit");
+
+        while (true)
+        {
+            var key = Console.ReadKey();
+            Console.WriteLine();
+
+            switch (key.Key)
+            {
+                case ConsoleKey.C:
+                    await SendCommand(messageSession);
+                    continue;
+                case ConsoleKey.R:
+                    await SendRequest(messageSession);
+                    continue;
+                case ConsoleKey.D:
+                    await Data(messageSession);
+                    continue;
+                case ConsoleKey.X:
+                    await Expiration(messageSession);
+                    continue;
+            }
+            return;
+
+        }
+    }
+
+    // Shut down server before sending this message, after 30 seconds, the message will be moved to Transactional dead-letter messages queue.
+    static Task Expiration(IMessageSession messageSession)
+    {
+        var messageThatExpires = new MessageThatExpires
+        {
+            RequestId = Guid.NewGuid()
+        };
+        Console.WriteLine("message with expiration was sent");
+        return messageSession.Send("Samples.Unobtrusive.Server", messageThatExpires);
+    }
+
+    static Task Data(IMessageSession messageSession)
+    {
+        var requestId = Guid.NewGuid();
+
+        var largeMessage = new LargeMessage
+        {
+            RequestId = requestId,
+            LargeDataBus = new byte[1024 * 1024 * 5]
+        };
+        Console.WriteLine($"Request sent id: {requestId}");
+        return messageSession.Send("Samples.Unobtrusive.Server", largeMessage);
+    }
+
+    static Task SendRequest(IMessageSession messageSession)
+    {
+        var requestId = Guid.NewGuid();
+
+        var request = new Request
+        {
+            RequestId = requestId
+        };
+        Console.WriteLine($"Request sent id: {requestId}");
+        return messageSession.Send("Samples.Unobtrusive.Server", request);
+    }
+
+    static Task SendCommand(IMessageSession messageSession)
+    {
+        var commandId = Guid.NewGuid();
+
+        var myCommand = new MyCommand
+        {
+            CommandId = commandId,
+        };
+        Console.WriteLine($"Command sent id: {commandId}");
+        return messageSession.Send("Samples.Unobtrusive.Server", myCommand);
+    }
+}

samples/unobtrusive/Core_10/Client/InputLoopService.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+using NServiceBus.Routing;
+
+namespace Client
+{
+    public class InputLoopService(IMessageSession messageSession) : BackgroundService
+    {
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            await CommandSender.Start(messageSession);
+
+        }
+    }
+}

samples/unobtrusive/Core_10/Client/MyEventHandler.cs

@@ -0,0 +1,11 @@
+using Events;
+using Microsoft.Extensions.Logging;
+
+public class MyEventHandler(ILogger<MyEventHandler> logger) : IHandleMessages<MyEvent>
+{
+    public Task Handle(MyEvent message, IMessageHandlerContext context)
+    {
+        logger.LogInformation("MyEvent received from server with id:{EventId}", message.EventId);
+        return Task.CompletedTask;
+    }
+}

samples/unobtrusive/Core_10/Client/Program.cs

@@ -0,0 +1,20 @@
+using Client;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+Console.Title = "Client";
+var builder = Host.CreateApplicationBuilder(args);
+builder.Services.AddHostedService<InputLoopService>();
+var endpointConfiguration = new EndpointConfiguration("Samples.Unobtrusive.Client");
+endpointConfiguration.UseSerialization<SystemJsonSerializer>();
+endpointConfiguration.UseTransport(new LearningTransport());
+#pragma warning disable CS0618 // Type or member is obsolete
+var dataBus = endpointConfiguration.UseDataBus<FileShareDataBus, SystemJsonDataBusSerializer>();
+dataBus.BasePath(@"..\..\..\..\DataBusShare\");
+#pragma warning restore CS0618 // Type or member is obsolete
+
+endpointConfiguration.ApplyCustomConventions();
+
+builder.UseNServiceBus(endpointConfiguration);
+
+await builder.Build().RunAsync();

samples/unobtrusive/Core_10/Client/ResponseHandler.cs

@@ -0,0 +1,11 @@
+using Messages;
+using Microsoft.Extensions.Logging;
+
+public class ResponseHandler(ILogger<ResponseHandler> logger) : IHandleMessages<Response>
+{
+    public Task Handle(Response message, IMessageHandlerContext context)
+    {
+        logger.LogInformation("Response received from server for request with id:{ResponseId}", message.ResponseId);
+        return Task.CompletedTask;
+    }
+}

samples/unobtrusive/Core_10/ConventionExtensions.cs

@@ -0,0 +1,38 @@
+public static class ConventionExtensions
+{
+    #region CustomConvention
+
+    public static void ApplyCustomConventions(this EndpointConfiguration endpointConfiguration)
+    {
+        var conventions = endpointConfiguration.Conventions();
+
+        conventions.DefiningCommandsAs(
+            type =>
+            type.Namespace != null &&
+            type.Namespace.EndsWith("Commands"));
+
+        conventions.DefiningEventsAs(
+            type =>
+            type.Namespace != null &&
+            type.Namespace.EndsWith("Events"));
+
+        conventions.DefiningMessagesAs(
+            type => type.Namespace == "Messages");
+#pragma warning disable CS0618 // Type or member is obsolete
+        conventions.DefiningDataBusPropertiesAs(
+            property => property.Name.EndsWith("DataBus"));
+#pragma warning restore CS0618 // Type or member is obsolete
+
+        conventions.DefiningTimeToBeReceivedAs(
+            type =>
+            {
+                if (type.Name.EndsWith("Expires"))
+                {
+                    return TimeSpan.FromSeconds(30);
+                }
+                return TimeSpan.MaxValue;
+            });
+    }
+
+    #endregion
+}

samples/unobtrusive/Core_10/Server/CommandSender.cs

@@ -0,0 +1,36 @@
+using Events;
+
+class CommandSender
+{
+    public static async Task Start(IMessageSession messageSession)
+    {
+        Console.WriteLine("Press 'E' to publish an event");
+        Console.WriteLine("Press any other key to exit");
+
+        while (true)
+        {
+            var key = Console.ReadKey();
+            Console.WriteLine();
+
+            switch (key.Key)
+            {
+                case ConsoleKey.E:
+                    await PublishEvent(messageSession);
+                    continue;
+            }
+            return;
+        }
+    }
+
+    static Task PublishEvent(IMessageSession messageSession)
+    {
+        var eventId = Guid.NewGuid();
+
+        Console.WriteLine($"Event published, id: {eventId}");
+        var myEvent = new MyEvent
+        {
+            EventId = eventId
+        };
+        return messageSession.Publish(myEvent);
+    }
+}

samples/unobtrusive/Core_10/Server/InputLoopService.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+
+namespace Server
+{
+    public class InputLoopService(IMessageSession messageSession) : BackgroundService
+    {
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            await CommandSender.Start(messageSession);
+        }
+    }
+}

samples/unobtrusive/Core_10/Server/LargeMessageHandler.cs

@@ -0,0 +1,18 @@
+using Messages;
+using Microsoft.Extensions.Logging;
+
+public class LargeMessageHandler(ILogger<LargeMessageHandler> logger) : IHandleMessages<LargeMessage>
+{
+    public Task Handle(LargeMessage message, IMessageHandlerContext context)
+    {
+        if (message.LargeDataBus == null)
+        {
+            logger.LogInformation("Message [{MessageType}] received, id:{RequestId}", message.GetType(), message.RequestId);
+        }
+        else
+        {
+            logger.LogInformation("Message [{MessageType}] received, id:{RequestId} and payload {PayloadLength} bytes", message.GetType(), message.RequestId, message.LargeDataBus.Length);
+        }
+        return Task.CompletedTask;
+    }
+}

samples/unobtrusive/Core_10/Server/MessageThatExpiresHandler.cs

@@ -0,0 +1,12 @@
+using Messages;
+using Microsoft.Extensions.Logging;
+
+public class MessageThatExpiresHandler(ILogger<MessageThatExpiresHandler> logger) : IHandleMessages<MessageThatExpires>
+{
+
+    public Task Handle(MessageThatExpires message, IMessageHandlerContext context)
+    {
+        logger.LogInformation("Message [{MessageType}] received, id: [{RequestId}]", message.GetType(), message.RequestId);
+        return Task.CompletedTask;
+    }
+}

samples/unobtrusive/Core_10/Server/MyCommandHandler.cs

@@ -0,0 +1,11 @@
+using Commands;
+using Microsoft.Extensions.Logging;
+
+public class MyCommandHandler(ILogger<MyCommandHandler> logger) : IHandleMessages<MyCommand>
+{
+    public Task Handle(MyCommand message, IMessageHandlerContext context)
+    {
+        logger.LogInformation("Command received, id:{CommandId}", message.CommandId);
+        return Task.CompletedTask;
+    }
+}

samples/unobtrusive/Core_10/Server/Program.cs

@@ -0,0 +1,21 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Server;
+
+Console.Title = "Server";
+var builder = Host.CreateApplicationBuilder(args);
+builder.Services.AddHostedService<InputLoopService>();
+
+var endpointConfiguration = new EndpointConfiguration("Samples.Unobtrusive.Server");
+endpointConfiguration.UseSerialization<SystemJsonSerializer>();
+endpointConfiguration.UseTransport(new LearningTransport());
+#pragma warning disable CS0618 // Type or member is obsolete
+endpointConfiguration.UseDataBus<FileShareDataBus, SystemJsonDataBusSerializer>()
+    .BasePath(@"..\..\..\..\DataBusShare\");
+#pragma warning restore CS0618 // Type or member is obsolete
+
+endpointConfiguration.ApplyCustomConventions();
+
+builder.UseNServiceBus(endpointConfiguration);
+
+await builder.Build().RunAsync();

samples/unobtrusive/Core_10/Server/RequestMessageHandler.cs

@@ -0,0 +1,15 @@
+using Messages;
+using Microsoft.Extensions.Logging;
+public class RequestMessageHandler(ILogger<RequestMessageHandler> logger) : IHandleMessages<Request>
+{
+    public Task Handle(Request message, IMessageHandlerContext context)
+    {
+        logger.LogInformation("Request received with id:{RequestId}", message.RequestId);
+
+        var response = new Response
+        {
+            ResponseId = message.RequestId
+        };
+        return context.Reply(response);
+    }
+}

samples/unobtrusive/Core_10/Server/Server.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+     <TargetFramework>net10.0</TargetFramework>
+     <LangVersion>preview</LangVersion>
+    <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+      <PackageReference Include="NServiceBus" Version="10.0.0-alpha.1" />
+      <PackageReference Include="NServiceBus.Extensions.Hosting" Version="4.0.0-alpha.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\ConventionExtensions.cs" />
+  </ItemGroup>
+
+</Project>

samples/unobtrusive/Core_10/Shared/LargeMessage.cs

@@ -0,0 +1,10 @@
+namespace Messages;
+
+using System;
+
+public class LargeMessage
+{
+    public Guid RequestId { get; set; }
+
+    public byte[]? LargeDataBus { get; set; }
+}