public void DbContextPoolTest()
{
int hashCode1, hashCode2;
var services = new ServiceCollection();
services.AddScoped <DbTest>();
using (var scope = ObjectProviderFactory.CreateScope(provider => provider.RegisterInstance(new DbTest(3))))
{
var dbContext = scope.GetService <DemoDbContext>();
hashCode1 = dbContext.GetHashCode();
dbContext.Database.AutoTransactionsEnabled = false;
var dbTest = scope.GetService <DbTest>();
Assert.Equal(3, dbTest.Count);
}
using (var scope = ObjectProviderFactory.CreateScope(provider => provider.RegisterInstance(new DbTest(1))))
{
var dbContext = scope.GetService <DemoDbContext>();
hashCode2 = dbContext.GetHashCode();
Assert.True(dbContext.Database.AutoTransactionsEnabled);
var dbTest = scope.GetService <DbTest>();
Assert.Equal(1, dbTest.Count);
}
Assert.Equal(hashCode1, hashCode2);
}
public async Task GetUsersTest()
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var serviceProvider = scope.GetService <IServiceProvider>();
if (serviceProvider == null)
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
logger.LogError((scope as ObjectProvider)?.UnityContainer.Registrations.ToJson());
Assert.NotNull(serviceProvider);
}
var dbContext = scope.GetService <DemoDbContext>();
var users = await dbContext.Users
//.Include(u => u.Cards)
.FindAll(u => !string.IsNullOrWhiteSpace(u.Name))
.Take(10)
.ToArrayAsync();
foreach (var u in users)
{
await u.LoadCollectionAsync(u1 => u1.Cards);
Assert.Equal(u.GetDbContext <DemoDbContext>().GetHashCode(), dbContext.GetHashCode());
}
}
}
public async Task AddPresonTest()
{
try
{
var id = DateTime.Now.Ticks;
using (var serviceScope = ObjectProviderFactory.CreateScope())
{
var dbContext = serviceScope.GetService <DemoDbContext>();
var person = new Person(id, "ivan");
dbContext.Persons.Add(person);
await dbContext.SaveChangesAsync();
}
using (var serviceScope = ObjectProviderFactory.CreateScope())
{
var dbContext = serviceScope.GetService <DemoDbContext>();
var person = await dbContext.Persons.FindAsync(id).ConfigureAwait(false);
Assert.NotNull(person);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void TestLog()
{
var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
Configuration.Instance
.UseAutofacContainer(new ContainerBuilder())
.UseConfiguration(builder.Build())
.UseJsonNet()
.UseLog4Net();
ObjectProviderFactory.Instance.Build();
var loggerFactory = ObjectProviderFactory.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger(GetType());
try
{
throw new NotImplementedException("test exception");
}
catch (Exception e)
{
LogTest(logger, e);
}
}
protected MessageSender(IMessageQueueClient messageQueueClient, string defaultTopic = null)
{
MessageQueueClient = messageQueueClient;
DefaultTopic = defaultTopic;
MessageStateQueue = new BlockingCollection <MessageState>();
Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
}
public EventSubscriber(IMessageQueueClient messageQueueClient,
IHandlerProvider handlerProvider,
ICommandBus commandBus,
IMessagePublisher messagePublisher,
string subscriptionName,
TopicSubscription[] topicSubscriptions,
string consumerId,
ConsumerConfig consumerConfig = null)
{
ConsumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
MessageQueueClient = messageQueueClient;
HandlerProvider = handlerProvider;
_topicSubscriptions = topicSubscriptions ?? new TopicSubscription[0];
_topicSubscriptions.Where(ts => ts.TagFilter != null)
.ForEach(ts => { TagFilters.Add(ts.Topic, ts.TagFilter); });
ConsumerId = consumerId;
SubscriptionName = subscriptionName;
MessagePublisher = messagePublisher;
CommandBus = commandBus;
var loggerFactory = ObjectProviderFactory.GetService <ILoggerFactory>();
MessageProcessor = new MailboxProcessor(new DefaultProcessingMessageScheduler(),
new OptionsWrapper <MailboxOption>(new MailboxOption
{
BatchCount = ConsumerConfig.MailboxProcessBatchCount
}),
loggerFactory.CreateLogger <MailboxProcessor>());
Logger = loggerFactory.CreateLogger(GetType().Name);
}
public EntityFrameworkTests()
{
var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
Configuration.Instance
//.UseMicrosoftDependencyInjection()
//.UseUnityContainer()
.UseAutofacContainer()
.UseConfiguration(builder.Build())
.UseCommonComponents()
.UseJsonNet()
.UseLog4Net()
.UseDbContextPool <DemoDbContext>(options =>
{
options.EnableSensitiveDataLogging();
options.UseMySQL(Configuration.Instance.GetConnectionString(DemoDbContextFactory.MySqlConnectionStringName));
//options.UseInMemoryDatabase(nameof(DemoDbContext));
//options.UseSqlServer(Configuration.Instance.GetConnectionString(DemoDbContextFactory.ConnectionStringName));
}, 1000);
ObjectProviderFactory.Instance.Build();
using (var serviceScope = ObjectProviderFactory.CreateScope())
{
var dbContext = serviceScope.GetService <DemoDbContext>();
dbContext.Database.Migrate();
}
}
static MessageSender()
{
NeedMessageStore = Configuration.Instance.NeedMessageStore;
if (NeedMessageStore)
{
ObjectProviderFactory.GetService <IMessageStoreDaemon>().Start();
}
}
public async Task Test1()
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var service = scope.GetService <IAliPayBankCardParseService>();
var result = await service.ParseBankCardAsync(cardNo : "6217920159440572");
}
}
public MessageQueueClient(IMessageQueueClientProvider clientProvider)
{
_clientProvider = clientProvider;
QueueClients = new ConcurrentDictionary <string, IMessageProducer>();
TopicClients = new ConcurrentDictionary <string, IMessageProducer>();
Subscribers = new List <IMessageConsumer>();
QueueConsumers = new List <IMessageConsumer>();
Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType().Name);
}
public async Task CrudTest()
{
User user = null;
using (var scope = ObjectProviderFactory.CreateScope())
{
var dbCtx = scope.GetRequiredService <DemoDbContext>();
var unitOfWork = scope.GetRequiredService <IUnitOfWork>();
var repository = scope.GetRequiredService <IDemoRepository>();
user = new User($"ivan-{DateTime.Now.Ticks}", "male");
repository.Add(user);
await unitOfWork.CommitAsync()
.ConfigureAwait(false);
}
var newName = $"new name {DateTime.Now.Ticks}";
using (var scope = ObjectProviderFactory.CreateScope())
{
var repository = scope.GetRequiredService <IDemoRepository>();
var unitOfWork = scope.GetRequiredService <IUnitOfWork>();
user = await repository.GetByKeyAsync <User>(user.Id)
.ConfigureAwait(false);
Assert.NotNull(user);
user.ModifyName(newName);
var dbCtx = scope.GetRequiredService <DemoDbContext>();
await unitOfWork.CommitAsync()
.ConfigureAwait(false);
}
using (var scope = ObjectProviderFactory.CreateScope())
{
var repository = scope.GetRequiredService <IDemoRepository>();
var unitOfWork = scope.GetRequiredService <IUnitOfWork>();
user = await repository.GetByKeyAsync <User>(user.Id)
.ConfigureAwait(false);
Assert.True(user.Name == newName);
repository.Remove(user);
await unitOfWork.CommitAsync()
.ConfigureAwait(false);
}
using (var scope = ObjectProviderFactory.CreateScope())
{
var repository = scope.GetRequiredService <IDemoRepository>();
user = await repository.GetByKeyAsync <User>(user.Id)
.ConfigureAwait(false);
Assert.Null(user);
}
}
public object GetHandler(Type messageType)
{
object handler = null;
var handlerType = GetHandlerType(messageType);
if (handlerType != null)
{
handler = ObjectProviderFactory.GetService(handlerType.Type);
}
return(handler);
}
protected MessageConsumer(string[] topics,
string groupId,
string consumerId,
ConsumerConfig consumerConfig = null)
{
Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
ConsumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
Topics = topics;
GroupId = groupId;
ConsumerId = consumerId ?? string.Empty;
SlidingDoors = new ConcurrentDictionary <string, SlidingDoor>();
}
public static Configuration UseMessagePublisher(this Configuration configuration, string defaultTopic)
{
var builder = ObjectProviderFactory.Instance.ObjectProviderBuilder;
builder.Register <IMessagePublisher>(provider =>
{
var messageQueueClient = ObjectProviderFactory.GetService <IMessageQueueClient>();
configuration.SetDefaultTopic(defaultTopic);
defaultTopic = configuration.FormatAppName(defaultTopic);
var messagePublisher = new MessagePublisher(messageQueueClient, defaultTopic);
return(messagePublisher);
}, ServiceLifetime.Singleton);
return(configuration);
}
public SlidingDoor(Action <MessageOffset> commitOffset,
string topic,
int partition,
bool commitPerMessage = false)
{
CommitOffset = commitOffset;
Topic = topic;
Partition = partition;
Offsets = new SortedSet <long>();
RemovedMessageOffsets = new SortedList <long, MessageOffset>();
CommitPerMessage = commitPerMessage;
_logger = ObjectProviderFactory.GetService <ILoggerFactory>()
.CreateLogger(GetType());
}
public async Task InnerJoinTest()
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var repository = scope.GetRequiredService <IDemoRepository>();
var query = from user in repository.FindAll <User>()
join card in repository.FindAll <Card>()
on user.Id equals card.Id
select new { user.Id, card.Name };
var sql = query.ToString();
var result = await query.ToListAsync();
}
}
public static void Bootstrap()
{
try
{
var kafkaBrokerList = new[]
{
new IPEndPoint(Utility.GetLocalIpv4(), 9092).ToString()
//"10.100.7.46:9092"
};
Configuration.Instance
.UseAutofacContainer(Assembly.GetExecutingAssembly().FullName,
"Sample.CommandHandler",
"Sample.DomainEventSubscriber",
"Sample.AsyncDomainEventSubscriber",
"Sample.ApplicationEventSubscriber")
.UseConfiguration(new ConfigurationBuilder().AddJsonFile("appsettings.json")
.Build())
.UseCommonComponents()
.UseJsonNet()
.UseLog4Net()
.UseEntityFrameworkComponents <SampleModelContext>()
.UseMessageStore <SampleModelContext>()
.UseInMemoryMessageQueue()
//.UseConfluentKafka(string.Join(",", kafkaBrokerList))
//.UseEQueue()
.UseCommandBus(Environment.MachineName, linerCommandManager: new LinearCommandManager())
.UseMessagePublisher("eventTopic")
.UseDbContextPool <SampleModelContext>(options => options.UseInMemoryDatabase(nameof(SampleModelContext)))
//.UseDbContextPool<SampleModelContext>(options => options.UseSqlServer(Configuration.GetConnectionString(nameof(SampleModelContext))))
;
ObjectProviderFactory.Instance
.RegisterComponents(RegisterComponents, ServiceLifetime.Scoped)
.Build();
StartMessageQueueComponents();
_Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(typeof(WebApiApplication).Name);
_Logger.LogDebug($"App Started");
}
catch (Exception ex)
{
_Logger.LogError(ex.GetBaseException().Message, ex);
}
}
public async Task AddUserTest()
{
using (var serviceScope = ObjectProviderFactory.CreateScope())
using (var scope = new TransactionScope(TransactionScopeOption.Required,
new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
},
TransactionScopeAsyncFlowOption.Enabled))
{
var serviceProvider = serviceScope.GetService <IServiceProvider>();
if (serviceProvider == null)
{
Assert.NotNull(serviceProvider);
}
try
{
var dbContext = serviceScope.GetService <DemoDbContext>();
if (dbContext == null)
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
logger.LogError((serviceScope as ObjectProvider)?.UnityContainer.Registrations.ToJson());
Assert.NotNull(dbContext);
}
var user = new User("ivan", "male");
user.AddCard("ICBC");
user.AddCard("CCB");
user.AddCard("ABC");
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
scope.Complete();
var client = dbContext.GetMongoDbClient();
var database = dbContext.GetMongoDbDatabase();
var conn = dbContext.GetMongoDbConnection();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public static IMessageProcessor CreateCommandConsumer(string commandQueue,
string consumerId,
string[] handlerProvierNames,
ConsumerConfig consumerConfig = null)
{
var container = ObjectProviderFactory.Instance.ObjectProvider;
var messagePublisher = container.GetService <IMessagePublisher>();
var handlerProvider = new CommandHandlerProvider(handlerProvierNames);
var messageQueueClient = ObjectProviderFactory.GetService <IMessageQueueClient>();
var commandConsumer = new CommandProcessor(messageQueueClient,
messagePublisher,
handlerProvider,
commandQueue,
consumerId,
consumerConfig);
return(commandConsumer);
}
public async Task AddPresonTest()
{
try
{
using (var serviceScope = ObjectProviderFactory.CreateScope())
{
var dbContext = serviceScope.GetService <DemoDbContext>();
var person = new Person("ivan");
dbContext.Persons.Add(person);
await dbContext.SaveChangesAsync();
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task GetUsersTest()
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var serviceProvider = scope.GetService <IServiceProvider>();
if (serviceProvider == null)
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
logger.LogError((scope as ObjectProvider)?.UnityContainer.Registrations.ToJson());
Assert.NotNull(serviceProvider);
}
//var options = new DbContextOptionsBuilder<DemoDbContext>();
//options.UseMongoDb(Configuration.Instance.GetConnectionString(DemoDbContextFactory.MongoDbConnectionStringName));
var dbContext = scope.GetService <DemoDbContext>();
try
{
var user = await dbContext.Users.FindAsync("5BEE29960CCE411C20215A17").ConfigureAwait(false);
// var connection = dbContext.GetMongoDbDatabase();
var users = await dbContext.Users
//.Include(u => u.Cards)
//.FindAll(u => !string.IsNullOrWhiteSpace(u.Name))
.Take(10)
.ToListAsync()
.ConfigureAwait(false);
//foreach (var u in users)
//{
// await u.LoadCollectionAsync(u1 => u1.Cards);
// Assert.True(u.Cards.Count > 0);
// //Assert.Equal(u.GetDbContext<DemoDbContext>().GetHashCode(), dbContext.GetHashCode());
//}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public CommandBus(IMessageQueueClient messageQueueClient,
ILinearCommandManager linearCommandManager,
string consumerId,
string replyTopicName,
string replySubscriptionName,
ConsumerConfig consumerConfig = null)
: base(messageQueueClient)
{
_consumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
_consumerId = consumerId;
_commandStateQueues = new ConcurrentDictionary <string, MessageState>();
_linearCommandManager = linearCommandManager;
_replyTopicName = Configuration.Instance.FormatAppName(replyTopicName);
_replySubscriptionName = Configuration.Instance.FormatAppName(replySubscriptionName);
// _commandQueueNames = commandQueueNames;
_messageProcessor = new MailboxProcessor(new DefaultProcessingMessageScheduler(),
new OptionsWrapper <MailboxOption>(new MailboxOption
{
BatchCount = _consumerConfig.MailboxProcessBatchCount
}),
ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger <MailboxProcessor>());
}
public CommandBusTests()
{
_logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(typeof(CommandBusTests));
_commandBus = ObjectProviderFactory.GetService <ICommandBus>();
_createProducts = new List <CreateProduct>();
var tasks = new List <Task>();
for (var i = 0; i < productCount; i++)
{
var createProduct = new CreateProduct
{
ProductId = Guid.NewGuid(),
Name = string.Format("{0}-{1}", DateTime.Now, i),
Count = 20000
};
_createProducts.Add(createProduct);
tasks.Add(_commandBus.SendAsync(createProduct, true).Result.Reply);
}
Task.WaitAll(tasks.ToArray());
}
public void Process(string fileName, InputConfiguration configuration)
{
var files = this.GetFileNames(fileName, configuration);
var objectTuples = new List <Tuple <ObjectBase, ObjectDefinitionBase> >();
foreach (var file in files)
{
var objectContainers = JsonConvert.DeserializeObject <List <ObjectContainer> >(File.ReadAllText(file));
foreach (var objectContainer in objectContainers)
{
var objectDefinition = ObjectProviderFactory.GetProvider(this.ServiceProvider, objectContainer.Object).Create(objectContainer.Object);
this.Definitions.Add(objectDefinition);
objectTuples.Add(new Tuple <ObjectBase, ObjectDefinitionBase>(objectContainer.Object, objectDefinition));
}
}
foreach (var objectTuple in objectTuples)
{
ObjectProviderFactory.GetProvider(this.ServiceProvider, objectTuple.Item1).Process(objectTuple.Item2, objectTuple.Item1, this);
}
}
public async Task DbContextPoolScopeTest()
{
var tasks = new object[10].Select(o => Task.Run(() =>
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var dbCtx = scope.GetService <DemoDbContext>();
var hashCode = dbCtx.GetHashCode();
dbCtx = scope.GetService <DemoDbContext>();
Assert.Equal(hashCode, dbCtx.GetHashCode());
dbCtx = scope.GetService <DemoDbContext>();
Assert.Equal(hashCode, dbCtx.GetHashCode());
_output.WriteLine($"dbctx hashcode {hashCode}");
}
})).ToArray();
await Task.WhenAll(tasks);
tasks = new object[10].Select(o => Task.Run(() =>
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var dbCtx = scope.GetService <DemoDbContext>();
var hashCode = dbCtx.GetHashCode();
dbCtx = scope.GetService <DemoDbContext>();
Assert.Equal(hashCode, dbCtx.GetHashCode());
dbCtx = scope.GetService <DemoDbContext>();
Assert.Equal(hashCode, dbCtx.GetHashCode());
_output.WriteLine($"dbctx hashcode {hashCode}");
}
})).ToArray();
await Task.WhenAll(tasks);
}
public static IMessageProcessor CreateEventSubscriber(TopicSubscription[] topicSubscriptions,
string subscription,
string consumerId,
string[] handlerProviderNames,
ConsumerConfig consumerConfig = null)
{
subscription = Configuration.Instance.FormatAppName(subscription);
var handlerProvider = new EventSubscriberProvider(handlerProviderNames);
var commandBus = GetCommandBus();
var messagePublisher = GetMessagePublisher();
var messageQueueClient = ObjectProviderFactory.GetService <IMessageQueueClient>();
var eventSubscriber = new EventSubscriber(messageQueueClient,
handlerProvider,
commandBus,
messagePublisher,
subscription,
topicSubscriptions,
consumerId,
consumerConfig);
return(eventSubscriber);
}
public async Task ConcurrentTest()
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
try
{
//await AddUserTest();
var tasks = new List <Task>();
for (int i = 0; i < 5; i++)
{
tasks.Add(GetUsersTest());
}
await Task.WhenAll(tasks);
logger.LogDebug($"incremented : {DemoDbContext.Total}");
}
catch (Exception e)
{
logger.LogError(e, $"incremented : {DemoDbContext.Total}");
throw;
}
}
public CommandProcessor(IMessageQueueClient messageQueueClient,
IMessagePublisher messagePublisher,
IHandlerProvider handlerProvider,
string commandQueueName,
string consumerId,
ConsumerConfig consumerConfig = null)
{
ConsumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
CommandQueueName = commandQueueName;
HandlerProvider = handlerProvider;
MessagePublisher = messagePublisher;
ConsumerId = consumerId;
CancellationTokenSource = new CancellationTokenSource();
MessageQueueClient = messageQueueClient;
var loggerFactory = ObjectProviderFactory.GetService <ILoggerFactory>();
MessageProcessor = new MailboxProcessor(new DefaultProcessingMessageScheduler(),
new OptionsWrapper <MailboxOption>(new MailboxOption
{
BatchCount = ConsumerConfig.MailboxProcessBatchCount
}),
loggerFactory.CreateLogger <MailboxProcessor>());
Logger = loggerFactory.CreateLogger(GetType().Name);
}
public async Task ConcurrentUdpateTest()
{
using (var serviceScope = ObjectProviderFactory.CreateScope())
{
var concurrencyProcessor = serviceScope.GetService <IConcurrencyProcessor>();
var dbContext = serviceScope.GetService <DemoDbContext>();
using (var transactionScope = new TransactionScope(TransactionScopeOption.Required,
new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted
},
TransactionScopeAsyncFlowOption.Enabled))
{
await concurrencyProcessor.ProcessAsync(async() =>
{
var account = await dbContext.Users.FirstOrDefaultAsync();
account.ModifyName($"ivan{DateTime.Now}");
await dbContext.SaveChangesAsync();
});
transactionScope.Complete();
}
}
}
private void RemoveMessages(CancellationTokenSource cancellationTokenSource)
{
while (!cancellationTokenSource.IsCancellationRequested)
{
try
{
var toRemoveMessages = new List <ToRemoveMessage>();
ToRemoveMessage toRemoveMessage = null;
do
{
_toRemoveMessages.TryDequeue(out toRemoveMessage);
if (toRemoveMessage != null)
{
toRemoveMessages.Add(toRemoveMessage);
}
} while (toRemoveMessages.Count < 10 && toRemoveMessage != null);
if (toRemoveMessages.Count == 0)
{
Task.Delay(1000).Wait();
}
else
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var messageStore = scope.GetService <IMessageStore>() as MessageStore;
if (messageStore == null)
{
throw new Exception("invalid messagestore!");
}
var toRemoveCommands = toRemoveMessages.Where(rm => rm.Type == MessageType.Command)
.Select(rm => rm.MessageId)
.ToArray();
if (toRemoveCommands.Length > 0)
{
RemoveUnSentCommands(messageStore, toRemoveCommands);
}
var toRemoveEvents = toRemoveMessages.Where(rm => rm.Type == MessageType.Event)
.Select(rm => rm.MessageId)
.ToArray();
if (toRemoveEvents.Length > 0)
{
RemoveUnPublishedEvents(messageStore, toRemoveEvents);
}
messageStore.SaveChanges();
}
}
}
catch (OperationCanceledException)
{
return;
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
_logger.LogError(ex, $"remove Messages Processing faield!");
}
}
}
