C# IJob.GetType方法代码示例

        public Task GetWork(IJob job)
        {
            Task task;
            try
            {
                task = job.Execute();
            }
            catch (Exception e)
            {
                QuietLog.LogHandledException(e);
                return new Task(() => {}); // returning dummy task so the job scheduler doesn't see errors
            }

            // wrapping the task inside an outer task which will continue with an error handler.
            return CreateWrappingContinuingTask(task, t =>
            {
                if (t.IsCanceled)
                {
                    Debug.WriteLine("Background Task Canceled: " + job.GetType());
                }
                else if (t.IsFaulted)
                {
                    Debug.WriteLine("Background Task Faulted: " + job.GetType());
                    QuietLog.LogHandledException(task.Exception);
                }
                // else happiness
            }, TaskContinuationOptions.ExecuteSynchronously);
        }

        /// <summary>
        /// Tries to create a JobDescriptor for the given job.
        /// </summary>
        /// <param name="job">
        /// The IJob object to create a descriptor for.
        /// </param>
        /// <returns>
        /// An instance of JobDescriptor that describes the job.
        /// </returns>
        public JobDescriptor CreateDescriptor(IJob job)
        {
            if (null == job)
            {
                throw new ArgumentNullException("job");
            }

            JobSpec spec;

            if (!typeToSpecMap.TryGetValue(job.GetType(), out spec))
            {
                throw new UnknownJobException(null, job.GetType().Name);
            }

            JobDescriptor descriptor = spec.Describe(job);

            return descriptor;
        }

        private Task<IJobId> ScheduleAsync(IJob job, Func<IBackgroundJobClient, JobDefinition, string, string> schedule)
        {
            var jobDefinition = _jobDefinitionService.GetJobDefinition(job.GetType());
            var json = _jsonSerializer.Serialize(job);

            var id = schedule(_backgroundJobClient, jobDefinition, json);

            _log.Verbose($"Scheduled job '{id}' in Hangfire");

            return Task.FromResult<IJobId>(new HangfireJobId(id));
        }

        public async Task<IJobId> ScheduleNowAsync(IJob job, CancellationToken cancellationToken)
        {
            var jobDefinition = _jobDefinitionService.GetJobDefinition(job.GetType());
            var json = _jsonSerializer.Serialize(job);

            _log.Verbose(() => $"Executing job '{jobDefinition.Name}' v{jobDefinition.Version}: {json}");

            // Don't schedule, just execute...
            await _jobRunner.ExecuteAsync(jobDefinition.Name, jobDefinition.Version, json, cancellationToken).ConfigureAwait(false);

            return JobId.New;
        }

        /**
            Método que pérmite calendarizar un nuevo job dentro de los cron del Sistema
        **/
        public static void scheduleJob(IJob jobToSchedule, String cronExpression)
        {

            JobDetailImpl       jobDetail = new JobDetailImpl("Job_" + jobCounter, "Group_" + jobCounter, jobToSchedule.GetType());
            CronTriggerImpl     trigger = null;
            DateTimeOffset?     dateTimOffset = null;

            if ( _scheduler == null)
            {
                initScheduler();
            }

            //Se crea el trigeer con el que se va a lanzar el job
            trigger = new CronTriggerImpl("Trigger_" + jobCounter, "Group_" + jobCounter, cronExpression);
            //Se agrega el calendarizador al scheduler
            _scheduler.ScheduleJob(jobDetail, trigger);

            //Se solicita el date Para el siguiente evento del scheduler
            dateTimOffset = trigger.GetNextFireTimeUtc();
            Console.WriteLine("Job Scheduled");
            Console.WriteLine(jobDetail.FullName + " its about to be fired at "  + dateTimOffset.Value );

            jobCounter++;
        }

        /// <summary>
        /// Gets the string used when persisting the type of an <see cref="IJob"/> into a <see cref="JobRecord"/>.
        /// </summary>
        /// <param name="job">The job to get the type string from.</param>
        /// <returns>A job type string.</returns>
        public static string JobTypeString(IJob job)
        {
            if (job == null)
            {
                throw new ArgumentNullException("job", "job cannot be null.");
            }

            return JobTypeString(job.GetType());
        }

        private bool InitializeJob(IJob job)
        {
            string jobName = job.GetType().Name;
            Logger.Instance.LogFormat(LogType.Info, this, Resources.JobInitializeBegin, jobName);

            try
            {
                if (!job.Initialize(_serviceProvider))
                {
                    Logger.Instance.LogFormat(LogType.Warning, this, Resources.JobInitializeError, jobName);
                    return false;
                }

                Logger.Instance.LogFormat(LogType.Info, this, Resources.JobInitializeSuccess, jobName);
                return true;
            }
            catch (Exception ex)
            {
                Logger.Instance.LogFormat(LogType.Error, this, Resources.JobGenericError, jobName, ex.Message);
                Logger.Instance.LogException(this, ex);
                return false;
            }
        }

        private void RunJobCore(IJobContext context, Operation operation, IJob job)
        {
            try
            {
                job.Execute(context, operation);

                Logger.Instance.LogFormat(LogType.Trace, this, Resources.JobExecuteFinished, job.GetType().Name);
            }
            catch (Exception ex)
            {
                string message = (job.IsAsync) ? Properties.Resources.JobExecuteAsyncFailed : Properties.Resources.JobExecuteSyncFailed;

                Logger.Instance.LogFormat(LogType.Warning, this, string.Format(message, job.GetType().Name));
                Logger.Instance.LogException(this, ex);
            }
        }

 private void RunJob(IJobContext context, Operation operation, IJob job)
 {
     if (job.IsAsync)
     {
         Logger.Instance.LogFormat(LogType.Info, this, Resources.JobExecuteAsyncStart, job.GetType().Name, context.Phase);
         ThreadPool.QueueUserWorkItem(o => RunJobCore(context, operation, job));
     }
     else
     {
         Logger.Instance.LogFormat(LogType.Info, this, Resources.JobExecuteSyncStart, job.GetType().Name, context.Phase);
         RunJobCore(context, operation, job);
     }
 }

 public Task<IJobId> ScheduleAsync(IJob job, TimeSpan delay, CancellationToken cancellationToken)
 {
     _log.Warning($"Instant scheduling configured, executing job '{job.GetType().PrettyPrint()}' NOW! Instead of in '{delay}'");
     return ScheduleNowAsync(job, cancellationToken);
 }

 public ScheduledJobRecord(IJob job)
 {
     JobKey = JobStatus.GetKey(job.GetType());
 }

 /// <summary>
 /// Allows the the job factory to destroy/cleanup the job if needed.
 /// </summary>
 /// <param name="job"></param>
 public void ReturnJob(IJob job)
 {
     this.logger.DebugFormat("Releasing the component for job '{0}'.", job.GetType());
     this.container.Release(job);
 }

        async Task RunJobAsync(IJob job, CancellationToken cancellationToken)
        {
            var jobtype = job.GetType()
                             .FullName;

            job.Log += InvokeLog;
            job.ExceptionThrown += InvokeExceptionThrown;

            try
            {
                InvokeLog($"\t\tJob {jobtype} {STARTED}");
                await job.RunAsync(cancellationToken);
            }
            catch (OperationCanceledException)
            {
                InvokeLog($"\t\tJob {jobtype} {CANCELLED}");
            }
            catch (Exception exception)
            {
                InvokeLog($"\t\tJob {jobtype} {ERRORED}");
                InvokeLog($"{jobtype} Exception{NewLine}{exception.ToText()}");
                InvokeExceptionThrown(job, new JobExceptionThrownEventArguments { Exception = exception, Job = job });
            }
            finally
            {
                job.ExceptionThrown -= InvokeExceptionThrown;
                job.Log -= InvokeLog;

                InvokeLog($"\t\tJob {jobtype} {FINISHED}");

                job.Dispose();
            }
        }

        private void RunJobCore(IJobContext context, Operation operation, IJob job)
        {
            // Run the job. If the job fails, ignore that exception as well but log it too!
            try
            {
                job.Execute(context, operation);
            }
            catch (Exception ex)
            {
                string message = (job.IsAsync) ? Properties.Resources.JobExecuteAsyncFailed : Properties.Resources.JobExecuteSyncFailed;

                // Be careful when processing the jobs, we don't want a malicious job to terminate the process!
                Logger.Instance.LogFormat(LogType.Warning, this, string.Format(message, job.GetType().Name));
                Logger.Instance.LogException(this, ex);
            }
        }