FarseerNet / Farseer.Net

    [Track] // Here, if marked, the Execute1 and Execute2 methods do not need to specify Track again.
    public class TrackDemo
    {
        [Track]
        public void Execute1() { }
        
        // Although I did not mark [Track], it is marked in the class and will be inherited here.
        public void Execute2() { }

        public void Execute3()
        {
            // If you are recording a code snippet, you can use this method
            using (FsLinkTrack.Track($"Generally, the MethodName is passed here"))
            {
                // doSomething
            }
        }
    }

/// <summary>
/// Open transaction (specify database configuration name)
/// </summary>
[TransactionName("test")] // Turn on transaction tagging
public void AopTransactionByName()
{
    // Get all data
    MetaInfoContext.Data.Task.ToList();
    // Write to entity objects
    MetaInfoContext.Data.Task.InsertAsync(po);
    // Get a single object
    MetaInfoContext.Data.Task.Where(o => o.Id == id).ToEntity();
    // Modify an object
    MetaInfoContext.Data.Task.UpdateAsync(po);
}

  // Get a Redis Instance
  var redisCacheManager = IocManager.GetService<IRedisCacheManager>();
  // hashSet
  await redisCacheManager.Db.HashSetAsync("test_sync", "init", "value");
  // keyDelete
  redisCacheManager.Db.KeyDelete("test_async");

// Define the key and set it to double-write for redis and local cache
var cacheServices = IocManager.Resolve<ICacheServices>();
cacheServices.SetProfilesInMemoryAndRedis<UserPO, int>("user", "default", o => o.Id, TimeSpan.FromSeconds(10));

// The cache is completely decoupled from database operations, and no code within the method is executed when the cache hits. It will be intercepted for processing
public class UserService
{
    /// <summary> Get the data set </summary>
    [Cache("user")]
    public IEnumerable<UserPO> ToList() => new DatabaseContext().ToList();
    /// <summary> Get the data set </summary>
    [Cache("user")]
    public UserPO ToEntity() => new DatabaseContext().ToList().FirstOrDefault();

    /// <summary> Simulate database add operation (cache must have a unique identifier) </summary>
    [CacheUpdate("user")]
    public UserPO Add(UserPO user)
    {
        new DatabaseContext().Add(user);
        return user;
    }

    /// <summary> Simulate database update data </summary>
    [CacheUpdate("user")]
    public UserPO Update(int id, UserPO user)
    {
        new DatabaseContext().Update(id, user);
        return user;
    }

    /// <summary> Simulate database deletion </summary>
    [CacheRemove("user")]
    public void Delete([CacheId] int id) => new DatabaseContext().Delete(id);
}

  var time = "30";
  // Judgment time (with complex local function methods)
  TestContext.Data.User.Where(o => o.CreateAt >= DateTime.Now.AddMinutes(-time.ConvertType(0)).ToTimestamps()).ToList();
  // NETS native conditionals and self-resolving conditionals
  TestContext.Data.User
             .Where(q => q.Term(t => t.Age, 33))
             .Where(o => o.UserName.Contains("ste")).ToList();
  // Fuzzy Search and Positive Order Sorting
  TestContext.Data.User.Where(o => o.Desc.Contains("hello")).Asc(o => o.Age).ToList();
  // Prefix search and reverse sorting
  TestContext.Data.User.Where(o => o.Desc.StartsWith("hello")).Desc(o => o.Age).ToList();
  // Suffix search (only Keyword type is supported)
  TestContext.Data.User.Where(o => o.UserName.EndsWith("en")).ToList();
  // Not equal to a value
  TestContext.Data.User.Where(o => o.UserName != "aaa").ToList();
  // and operation, if two Where methods are called, is also equivalent to using and
  TestContext.Data.User.Where(o => o.UserName == "steden" && o.Age == 18).ToList();
  // or operation
  TestContext.Data.User.Where(o => o.UserName == "steden" || o.Age >= 10).ToList();

// get instance
var rabbitProduct = IocManager.GetService<IRabbitManager>("test").Product;
// send
rabbitProduct.Send(message: "test send message");

/// <summary> Consumer Client </summary>
[Consumer(Enable = false, Name = "default", ExchangeName = "test", QueueName = "test", ExchangeType = eumExchangeType.fanout, DlxExchangeName = "DeadLetter")]
public class TestConsumer : IListenerMessage
{
    public bool Consumer(string message, object sender, BasicDeliverEventArgs ea)
    {
        System.Console.WriteLine(ea.ConsumerTag + "this message is:" + message);
        return true;
    }
}

IocManager.GetService<IEventProduct>(name: "test").Send(null, message: "hello event");

/// <summary>
/// Test events
/// </summary>
[Consumer(EventName = "test")]
public class TestEvent : IListenerMessage
{
    public async Task<bool> Consumer(string message, object sender, DomainEventArgs ea)
    {
        Console.WriteLine($"{ea.Id} I subscribe to test's messages：time：{ea.CreateAt} message：{message}");
        return true;
    }
}

  // instance
  var queueProduct = IocManager.GetService<IQueueProduct>(name: "test");
  // send
  queueProduct.Send("test send message");

  /// <summary>
  ///     Consumer Client
  /// </summary>
  [Consumer(Enable = true, Name = "test")]
  public class TestConsumer : IListenerMessage
  {
      public Task<bool> Consumer(List<object> queueList)
      {
          Console.WriteLine(value: $"get {queueList.Count} count");
          return Task.FromResult(result: true);
      }
      public Task<bool> FailureHandling(List<object> messages) => throw new NotImplementedException();
  }

  // instance
  var redisStreamProduct = IocManager.GetService<IRedisStreamProduct>("test2");
  // send
  redisStreamProduct.Send(message: "test send message");

  /// <summary>
  ///     Consumer Client
  /// </summary>
  [Consumer(Enable = true, RedisName = "default", GroupName = "", QueueName = "test2", PullCount = 2, ConsumeThreadNums = 1)]
  public class TestConsumer : IListenerMessage
  {
      public Task<bool> Consumer(ConsumeContext context)
      {
          foreach (var redisStreamMessage in context.RedisStreamMessages)
          {
              Console.WriteLine(value: "this message is:" + redisStreamMessage.Message);
              redisStreamMessage.Ack();
          }
  
          return Task.FromResult(result: true);
      }
  }

  [Fss] // Open before you can register to the FSS platform
  public class Program
  {
      public static void Main()
      {
          // Initialize
          FarseerApplication.Run<StartupModule>().Initialize();
          Thread.Sleep(millisecondsTimeout: -1);
      }
  }
    
  [FssJob(Name = "testJob")] // Name is consistent with the JobName configured in the FSS platform
  public class HelloWorldJob : IFssJob
  {
      /// <summary>
      ///     Execution of tasks
      /// </summary>
      public async Task<bool> Execute(IFssContext context)
      {
          // Tell the FSS platform that 20% of the current progress has been executed
          await context.SetProgressAsync(rate: 20);
  
          // Let the FSS platform, logging logs
          await context.LoggerAsync(logLevel: LogLevel.Information, log: "hello world！");
  
          // Next execution time is after 10 seconds (if not set, the time set by the task group is used)
          //context.SetNextAt(TimeSpan.FromSeconds(10));
  
          // success
          return true;
      }
  }

  [Tasks] // Turn it on to automatically register JOBs in
  public class Program
  {
      public static void Main()
      {
          // Initialize
          FarseerApplication.Run<StartupModule>().Initialize();
          Thread.Sleep(millisecondsTimeout: -1);
      }
  }
    
  [Job(Interval = 200)] // Need to attach Job feature and set execution interval
  public class HelloWorldJob : IJob
  {
      /// <summary>
      ///     Execution of tasks
      /// </summary>
      public Task Execute(ITaskContext context)
      {
          // Let the job platform, logging logs
          context.Logger(logLevel: LogLevel.Information, log: "hello world！");

          context.SetNext(TimeSpan.FromSeconds(5));
          // success
          return Task.FromResult(0);
      }
  }

    UserVO vo = new UserPO().Map<UserVO>();