完成基本测试代码

samples/apis/Backet.Api/Controllers/BacketController.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Linq.Expressions;
+using System.Runtime;
 using System.Text;
 using System.Text;
 using System.Threading.Tasks;
 using System.Threading.Tasks;
 using Backet.Api.Domain.Event;
 using Backet.Api.Domain.Event;
@@ -12,6 +13,7 @@ using Dapper;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging;
 using Npgsql;
 using Npgsql;
 using Orleans;
 using Orleans;
@@ -20,6 +22,7 @@ using Pole.Core.EventBus.Event;
 using Pole.Core.EventBus.EventHandler;
 using Pole.Core.EventBus.EventHandler;
 using Pole.Core.EventBus.EventStorage;
 using Pole.Core.EventBus.EventStorage;
 using Pole.Core.Serialization;
 using Pole.Core.Serialization;
+using Pole.Core.UnitOfWork;
 using Pole.Core.Utils.Abstraction;
 using Pole.Core.Utils.Abstraction;
 
 
 namespace Backet.Api.Controllers
 namespace Backet.Api.Controllers
@@ -35,8 +38,9 @@ namespace Backet.Api.Controllers
         private readonly ISerializer serializer;
         private readonly ISerializer serializer;
         private readonly ISnowflakeIdGenerator snowflakeIdGenerator;
         private readonly ISnowflakeIdGenerator snowflakeIdGenerator;
         private readonly IEventBuffer eventBuffer;
         private readonly IEventBuffer eventBuffer;
+        private readonly IServiceProvider serviceProvider;
         public BacketController(IClusterClient clusterClient, ILogger<BacketController> logger, IProducerInfoContainer producerContainer,
         public BacketController(IClusterClient clusterClient, ILogger<BacketController> logger, IProducerInfoContainer producerContainer,
-            IEventTypeFinder eventTypeFinder, ISerializer serializer, ISnowflakeIdGenerator snowflakeIdGenerator, IEventBuffer eventBuffer)
+            IEventTypeFinder eventTypeFinder, ISerializer serializer, ISnowflakeIdGenerator snowflakeIdGenerator, IEventBuffer eventBuffer, IServiceProvider serviceProvider)
         {
         {
             this.clusterClient = clusterClient;
             this.clusterClient = clusterClient;
             this.logger = logger;
             this.logger = logger;
@@ -45,18 +49,43 @@ namespace Backet.Api.Controllers
             this.serializer = serializer;
             this.serializer = serializer;
             this.snowflakeIdGenerator = snowflakeIdGenerator;
             this.snowflakeIdGenerator = snowflakeIdGenerator;
             this.eventBuffer = eventBuffer;
             this.eventBuffer = eventBuffer;
+            this.serviceProvider = serviceProvider;
         }
         }
         [HttpPost("api/backet/AddBacket")]
         [HttpPost("api/backet/AddBacket")]
-        public Task<bool> AddBacket([FromBody]Backet.Api.Grains.Abstraction.BacketDto backet)
+        public  Task<bool> AddBacket([FromBody]Backet.Api.Grains.Abstraction.BacketDto backetDto)
         {
         {
             var newId = Guid.NewGuid().ToString("N").ToLower();
             var newId = Guid.NewGuid().ToString("N").ToLower();
-            backet.Id = newId;
+            backetDto.Id = newId;
             var grain = clusterClient.GetGrain<IAddBacketGrain>(newId);
             var grain = clusterClient.GetGrain<IAddBacketGrain>(newId);
-            return grain.AddBacket(backet);
+            //var unitOfWork = serviceProvider.GetRequiredService<IUnitOfWork>();
+            //var dbContext = serviceProvider.GetRequiredService<BacketDbContext>();
+            //var bus = serviceProvider.GetRequiredService<IBus>();
+            //using (var transaction = await dbContext.Database.BeginTransactionAsync())
+            //{
+            //    unitOfWork.Enlist(transaction, bus);
+            //    Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet backet = new Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet
+            //    {
+            //        Id = backetDto.Id,
+            //        UserId = backetDto.UserId
+            //    };
+            //    if (backetDto.BacketItems == null || backetDto.BacketItems.Count == 0) return false;
+            //    backetDto.BacketItems.ForEach(item =>
+            //    {
+            //        backet.AddBacketItem(item.ProductId, item.ProductName, item.Price);
+            //    });
+            //    dbContext.Backets.Add(backet);
+            //    await bus.Publish(new BacketCreatedEvent() { BacketId = backet.Id });
+            //    await unitOfWork.CompeleteAsync();
+            //}
+            //return true;
+
+            return grain.AddBacket(backetDto);
         }
         }
         [HttpPost("api/backet/UpdateBacket")]
         [HttpPost("api/backet/UpdateBacket")]
         public Task<bool> UpdateBacket()
         public Task<bool> UpdateBacket()
         {
         {
+            GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.Default;
+            System.GC.Collect();
             var id = "67bbf594246441a18d7b6c74a277d06a";
             var id = "67bbf594246441a18d7b6c74a277d06a";
             var grain = clusterClient.GetGrain<IBacketGrain>(id);
             var grain = clusterClient.GetGrain<IBacketGrain>(id);
             return grain.UpdateBacket("99");
             return grain.UpdateBacket("99");

samples/apis/Backet.Api/Grains/AddBacketGrain.cs

@@ -20,13 +20,11 @@ namespace Backet.Api.Grains
             using (var scope = ServiceProvider.CreateScope())
             using (var scope = ServiceProvider.CreateScope())
             {
             {
                 var unitOfWork = scope.ServiceProvider.GetRequiredService<IUnitOfWork>();
                 var unitOfWork = scope.ServiceProvider.GetRequiredService<IUnitOfWork>();
-                var dbTransactionAdapter = scope.ServiceProvider.GetRequiredService<IDbTransactionAdapter>();
                 var dbContext = scope.ServiceProvider.GetRequiredService<BacketDbContext>();
                 var dbContext = scope.ServiceProvider.GetRequiredService<BacketDbContext>();
                 var bus = scope.ServiceProvider.GetRequiredService<IBus>();
                 var bus = scope.ServiceProvider.GetRequiredService<IBus>();
                 using (var transaction = await dbContext.Database.BeginTransactionAsync())
                 using (var transaction = await dbContext.Database.BeginTransactionAsync())
                 {
                 {
-                    dbTransactionAdapter.DbTransaction = transaction;
-                    unitOfWork.Enlist(dbTransactionAdapter, bus);
+                    unitOfWork.Enlist(transaction, bus);
                     Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet backet = new Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet
                     Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet backet = new Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet
                     {
                     {
                         Id = backetDto.Id,
                         Id = backetDto.Id,
@@ -43,7 +41,6 @@ namespace Backet.Api.Grains
                 }
                 }
                 return true;
                 return true;
             }
             }
-               
         }
         }
     }
     }
 }
 }

samples/apis/Backet.Api/Grains/BacketGrain.cs

@@ -14,22 +14,22 @@ namespace Backet.Api.Grains
     {
     {
         public async Task<bool> AddBacket(BacketDto backetDto)
         public async Task<bool> AddBacket(BacketDto backetDto)
         {
         {
-            
-            if (State != null) return false;
 
 
-            Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet backet = new Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet
-            {
-                Id = backetDto.Id,
-                UserId = backetDto.UserId
-            };
-            if (backetDto.BacketItems == null || backetDto.BacketItems.Count == 0) return false;
-            backetDto.BacketItems.ForEach(item =>
-            {
-                backet.AddBacketItem(item.ProductId, item.ProductName, item.Price);
-            });
-            Add(backet);
-            backet.AddDomainEvent(new BacketCreatedEvent() { BacketId = backet.Id });
-            await WriteStateAsync();
+            //if (State != null) return false;
+
+            //Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet backet = new Backet.Api.Domain.AggregatesModel.BacketAggregate.Backet
+            //{
+            //    Id = backetDto.Id,
+            //    UserId = backetDto.UserId
+            //};
+            //if (backetDto.BacketItems == null || backetDto.BacketItems.Count == 0) return false;
+            //backetDto.BacketItems.ForEach(item =>
+            //{
+            //    backet.AddBacketItem(item.ProductId, item.ProductName, item.Price);
+            //});
+            //Add(backet);
+            //backet.AddDomainEvent(new BacketCreatedEvent() { BacketId = backet.Id });
+            //await WriteStateAsync();
             return true;
             return true;
         }
         }
 
 

samples/apis/Backet.Api/Program.cs

@@ -10,6 +10,7 @@ using Orleans;
 using Orleans.Hosting;
 using Orleans.Hosting;
 using Pole.Orleans.Provider.EntityframeworkCore;
 using Pole.Orleans.Provider.EntityframeworkCore;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging;
+using Orleans.Configuration;
 
 
 namespace Backet.Api
 namespace Backet.Api
 {
 {
@@ -26,18 +27,14 @@ namespace Backet.Api
                 {
                 {
                     siloBuilder.UseLocalhostClustering();
                     siloBuilder.UseLocalhostClustering();
                     siloBuilder.AddEfGrainStorage<BacketDbContext>("ef");
                     siloBuilder.AddEfGrainStorage<BacketDbContext>("ef");
+                    siloBuilder.Configure<GrainCollectionOptions>(options =>
+                    {
+                        options.CollectionAge = TimeSpan.FromMinutes(2);
+                    });
                 })
                 })
                 .ConfigureWebHostDefaults(webBuilder =>
                 .ConfigureWebHostDefaults(webBuilder =>
                 {
                 {
                     webBuilder.UseStartup<Startup>();
                     webBuilder.UseStartup<Startup>();
-                })
-            .ConfigureLogging((hostingContext, logging) =>
-            {
-            // The ILoggingBuilder minimum level determines the
-            // the lowest possible level for logging. The log4net
-            // level then sets the level that we actually log at.
-            logging.AddLog4Net();
-            logging.SetMinimumLevel(LogLevel.Warning);
-        });
+                });
     }
     }
 }
 }

src/Pole.Core/UnitOfWork/IUnitOfWork.cs

@@ -15,5 +15,6 @@ namespace Pole.Core.UnitOfWork
         Task CompeleteAsync(CancellationToken cancellationToken = default);
         Task CompeleteAsync(CancellationToken cancellationToken = default);
         Task Rollback(CancellationToken cancellationToken = default);
         Task Rollback(CancellationToken cancellationToken = default);
         IUnitOfWork Enlist(IDbTransactionAdapter dbTransactionAdapter, IBus bus);
         IUnitOfWork Enlist(IDbTransactionAdapter dbTransactionAdapter, IBus bus);
+        IServiceProvider ServiceProvider { get; }
     }
     }
 }
 }

src/Pole.Core/UnitOfWork/UnitOfWork.cs

@@ -24,13 +24,15 @@ namespace Pole.Core.UnitOfWork
         private readonly ISerializer serializer;
         private readonly ISerializer serializer;
         private IBus bus;
         private IBus bus;
         private IEventBuffer eventBuffer;
         private IEventBuffer eventBuffer;
+        public IServiceProvider ServiceProvider { get; }
         public UnitOfWork(IProducerInfoContainer producerContainer, IEventTypeFinder eventTypeFinder,
         public UnitOfWork(IProducerInfoContainer producerContainer, IEventTypeFinder eventTypeFinder,
-            ISerializer serializer, IEventBuffer eventBuffer)
+            ISerializer serializer, IEventBuffer eventBuffer, IServiceProvider serviceProvider)
         {
         {
             this.producerContainer = producerContainer;
             this.producerContainer = producerContainer;
             this.eventTypeFinder = eventTypeFinder;
             this.eventTypeFinder = eventTypeFinder;
             this.serializer = serializer;
             this.serializer = serializer;
             this.eventBuffer = eventBuffer;
             this.eventBuffer = eventBuffer;
+            this.ServiceProvider = serviceProvider;
         }
         }
 
 
         public async Task CompeleteAsync(CancellationToken cancellationToken = default)
         public async Task CompeleteAsync(CancellationToken cancellationToken = default)

src/Pole.EventStorage.PostgreSql/IUnitOfWorkExtensions.cs

+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.Extensions.DependencyInjection;
+using Pole.Core.EventBus;
+using Pole.Core.EventBus.Transaction;
+using Pole.Core.UnitOfWork;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Text;
+
+namespace Pole.Core.UnitOfWork
+{
+    public static class IUnitOfWorkExtensions
+    {
+        public static IUnitOfWork Enlist(this IUnitOfWork unitOfWork, IDbContextTransaction dbContextTransaction, IBus bus)
+        {
+            var dbTransactionAdapter = unitOfWork.ServiceProvider.GetRequiredService<IDbTransactionAdapter>();
+            dbTransactionAdapter.DbTransaction = dbContextTransaction;
+            unitOfWork.Enlist(dbTransactionAdapter, bus);
+            return unitOfWork;
+        }
+        public static IUnitOfWork Enlist(this IUnitOfWork unitOfWork, IDbTransaction dbTransaction, IBus bus)
+        {
+            var dbTransactionAdapter = unitOfWork.ServiceProvider.GetRequiredService<IDbTransactionAdapter>();
+            dbTransactionAdapter.DbTransaction = dbTransaction;
+            unitOfWork.Enlist(dbTransactionAdapter, bus);
+            return unitOfWork;
+        }
+    }
+}