Update background jobs.

docs/en/Background-Jobs-RabbitMq.md

@@ -90,7 +90,7 @@ Using these options classes can be combined with the `appsettings.json` way. Con
 
 By default, each job type uses a separate queue. Queue names are calculated by combining a standard prefix and the job name. Default prefix is `AbpBackgroundJobs.` So, if the job name is `EmailSending` then the queue name in the RabbitMQ becomes `AbpBackgroundJobs.EmailSending`
 
-> Use `BackgroundJobName` attribute on the background job class to specify the job name. Otherwise, the job name will be the full name (with namespace) of the job class.
+> Use `BackgroundJobName` attribute on the background **job argument** class to specify the job name. Otherwise, the job name will be the full name (with namespace) of the job class.
 
 #### Job Connections
 
@@ -106,9 +106,9 @@ By default, all the job types use the `Default` RabbitMQ connection.
 Configure<AbpRabbitMqBackgroundJobOptions>(options =>
 {
     options.DefaultQueueNamePrefix = "my_app_jobs.";
-    options.JobQueues[typeof(EmailSendingJob)] =
+    options.JobQueues[typeof(EmailSendingArgs)] =
         new JobQueueConfiguration(
-            typeof(EmailSendingJob),
+            typeof(EmailSendingArgs),
             queueName: "my_app_jobs.emails",
             connectionName: "SecondConnection"
         );
@@ -116,7 +116,7 @@ Configure<AbpRabbitMqBackgroundJobOptions>(options =>
 ````
 
 * This example sets the default queue name prefix to `my_app_jobs.`. If different applications use the same RabbitMQ server, it would be important to use different prefixes for each application to not consume jobs of each other.
-* Also specifies a different connection string for the `EmailSendingJob`.
+* Also specifies a different connection string for the `EmailSendingArgs`.
 
 `JobQueueConfiguration` class has some additional options in its constructor;
 
@@ -126,4 +126,8 @@ Configure<AbpRabbitMqBackgroundJobOptions>(options =>
 * `exclusive` (optional, default: `false`).
 * `autoDelete` (optional, default: `false`)
 
-See the RabbitMQ documentation if you want to understand the `durable`, `exclusive` and `autoDelete` options better, while most of the times the default configuration is what you want. 
+See the RabbitMQ documentation if you want to understand the `durable`, `exclusive` and `autoDelete` options better, while most of the times the default configuration is what you want. 
+
+## See Also
+
+* [Background Jobs](Background-Jobs.md)

docs/en/Background-Jobs.md

@@ -13,7 +13,7 @@ Background jobs are **persistent** that means they will be **re-tried** and **ex
 
 ABP provides an **abstraction** module and **several implementations** for background jobs. It has a built-in/default implementation as well as Hangfire, RabbitMQ and Quartz integrations.
 
-`Volo.Abp.BackgroundJobs.Abstractions` nuget package provides needed services to create background jobs and queue background job items. If your module only depend on this package, it can be independent from the actual implementation/integration.
+`Volo.Abp.BackgroundJobs.Abstractions` NuGet package provides needed services to create background jobs and queue background job items. If your module only depend on this package, it can be independent from the actual implementation/integration.
 
 > `Volo.Abp.BackgroundJobs.Abstractions` package is installed to the startup templates by default.
 
@@ -24,18 +24,23 @@ A background job is a class that implements the `IBackgroundJob<TArgs>` interfac
 This example is used to send emails in background. First, define a class to store arguments of the background job:
 
 ````csharp
-public class EmailSendingArgs
+namespace MyProject
 {
-    public string EmailAddress { get; set; }
-    public string Subject { get; set; }
-    public string Body { get; set; }
+    public class EmailSendingArgs
+    {
+        public string EmailAddress { get; set; }
+        public string Subject { get; set; }
+        public string Body { get; set; }
+    }
 }
 ````
 
 Then create a background job class that uses an `EmailSendingArgs` object to send an email:
 
 ````csharp
+using System.Threading.Tasks;
 using Volo.Abp.BackgroundJobs;
+using Volo.Abp.DependencyInjection;
 using Volo.Abp.Emailing;
 
 namespace MyProject
@@ -70,6 +75,29 @@ This job simply uses `IEmailSender` to send emails (see [email sending document]
 
 A background job should not hide exceptions. If it throws an exception, the background job is automatically re-tried after a calculated waiting time. Hide exceptions only if you don't want to re-run the background job for the current argument.
 
+#### Job Name
+
+Each background job has a name. Job names are used in several places. For example, RabbitMQ provider uses job names to determine the RabbitMQ Queue names.
+
+Job name is determined by the **job argument type**. For the `EmailSendingArgs` example above, the job name is `MyProject.EmailSendingArgs` (full name, including the namespace). You can use the `BackgroundJobName` attribute to set a different job name.
+
+**Example**
+
+```csharp
+using Volo.Abp.BackgroundJobs;
+
+namespace MyProject
+{
+    [BackgroundJobName("emails")]
+    public class EmailSendingArgs
+    {
+        public string EmailAddress { get; set; }
+        public string Subject { get; set; }
+        public string Body { get; set; }
+    }
+}
+```
+
 ### Queue a Job Item
 
 Now, you can queue an email sending job using the `IBackgroundJobManager` service: