Use Json serialization/deserialization entity.

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Domain/Repositories/MemoryDb/IMemoryDatabaseCollection.cs

@@ -9,7 +9,5 @@ namespace Volo.Abp.Domain.Repositories.MemoryDb
         void Update(TEntity entity);
 
         void Remove(TEntity entity);
-
-        bool Contains(TEntity entity);
     }
 }

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Domain/Repositories/MemoryDb/IMemoryDbSerializer.cs

@@ -1,9 +1,11 @@
-namespace Volo.Abp.Domain.Repositories.MemoryDb
+using System;
+
+namespace Volo.Abp.Domain.Repositories.MemoryDb
 {
     public interface IMemoryDbSerializer
     {
-        object Serialize(object obj);
+        byte[] Serialize(object obj);
 
-        object Deserialize(object obj);
+        object Deserialize(byte[] value, Type type);
     }
 }

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Domain/Repositories/MemoryDb/MemoryDatabase.cs

@@ -1,18 +1,23 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Entities;
 
 namespace Volo.Abp.Domain.Repositories.MemoryDb
 {
-    public class MemoryDatabase : IMemoryDatabase
+    public class MemoryDatabase : IMemoryDatabase, ITransientDependency
     {
         private readonly ConcurrentDictionary<Type, object> _sets;
 
         private readonly ConcurrentDictionary<Type, InMemoryIdGenerator> _entityIdGenerators;
 
-        public MemoryDatabase()
+        private readonly IServiceProvider _serviceProvider;
+
+        public MemoryDatabase(IServiceProvider serviceProvider)
         {
+            _serviceProvider = serviceProvider;
             _sets = new ConcurrentDictionary<Type, object>();
             _entityIdGenerators = new ConcurrentDictionary<Type, InMemoryIdGenerator>();
         }
@@ -21,8 +26,8 @@ namespace Volo.Abp.Domain.Repositories.MemoryDb
             where TEntity : class, IEntity
         {
             return _sets.GetOrAdd(typeof(TEntity),
-                    _ => new MemoryDatabaseCollection<TEntity>(new MemoryDbBinarySerializer())) as
-                MemoryDatabaseCollection<TEntity>;
+                    _ => _serviceProvider.GetRequiredService<IMemoryDatabaseCollection<TEntity>>()) as
+                IMemoryDatabaseCollection<TEntity>;
         }
 
         public TKey GenerateNextId<TEntity, TKey>()

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Domain/Repositories/MemoryDb/MemoryDatabaseCollection.cs

@@ -8,7 +8,7 @@ namespace Volo.Abp.Domain.Repositories.MemoryDb
     public class MemoryDatabaseCollection<TEntity> : IMemoryDatabaseCollection<TEntity>
         where TEntity : class, IEntity
     {
-        private readonly Dictionary<string, object> _dictionary = new Dictionary<string, object>();
+        private readonly Dictionary<string, byte[]> _dictionary = new Dictionary<string, byte[]>();
 
         private readonly IMemoryDbSerializer _memoryDbSerializer;
 
@@ -21,7 +21,7 @@ namespace Volo.Abp.Domain.Repositories.MemoryDb
         {
             foreach (var entity in _dictionary.Values)
             {
-                yield return _memoryDbSerializer.Deserialize(entity).As<TEntity>();
+                yield return _memoryDbSerializer.Deserialize(entity, typeof(TEntity)).As<TEntity>();
             }
         }
 
@@ -48,11 +48,6 @@ namespace Volo.Abp.Domain.Repositories.MemoryDb
             _dictionary.Remove(GetEntityKey(entity));
         }
 
-        public bool Contains(TEntity entity)
-        {
-            return _dictionary.ContainsKey(GetEntityKey(entity));
-        }
-
         private string GetEntityKey(TEntity entity)
         {
             return entity.GetKeys().JoinAsString(",");

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Domain/Repositories/MemoryDb/MemoryDatabaseManager.cs

@@ -1,19 +1,25 @@
-using System.Collections.Concurrent;
+using System;
+using System.Collections.Concurrent;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.DependencyInjection;
 
 namespace Volo.Abp.Domain.Repositories.MemoryDb
 {
-    public static class MemoryDatabaseManager
+    public class MemoryDatabaseManager : ISingletonDependency
     {
-        private static ConcurrentDictionary<string, IMemoryDatabase> _databases;
+        private readonly ConcurrentDictionary<string, IMemoryDatabase> _databases =
+            new ConcurrentDictionary<string, IMemoryDatabase>();
 
-        static MemoryDatabaseManager()
+        private readonly IServiceProvider _serviceProvider;
+
+        public MemoryDatabaseManager(IServiceProvider serviceProvider)
         {
-            _databases = new ConcurrentDictionary<string, IMemoryDatabase>();
+            _serviceProvider = serviceProvider;
         }
 
-        public static IMemoryDatabase Get(string databaseName)
+        public IMemoryDatabase Get(string databaseName)
         {
-            return _databases.GetOrAdd(databaseName, _ => new MemoryDatabase());
+            return _databases.GetOrAdd(databaseName, _ => _serviceProvider.GetRequiredService<IMemoryDatabase>());
         }
     }
 }

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Domain/Repositories/MemoryDb/MemoryDbBinarySerializer.cs

@@ -1,29 +0,0 @@
-using System.IO;
-using System.Runtime.Serialization.Formatters.Binary;
-using Volo.Abp.DependencyInjection;
-
-namespace Volo.Abp.Domain.Repositories.MemoryDb
-{
-    public class MemoryDbBinarySerializer : IMemoryDbSerializer, ITransientDependency
-    {
-        public object Serialize(object obj)
-        {
-            var stream = new MemoryStream();
-            var formatter = new BinaryFormatter();
-            formatter.Serialize(stream, obj);
-            return stream;
-        }
-
-        public object Deserialize(object obj)
-        {
-            if (!(obj is MemoryStream stream))
-            {
-                return null;
-            }
-
-            var formatter = new BinaryFormatter();
-            stream.Seek(0, SeekOrigin.Begin);
-            return formatter.Deserialize(stream);
-        }
-    }
-}

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Domain/Repositories/MemoryDb/Utf8JsonMemoryDbSerializer.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Text;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Json;
+
+namespace Volo.Abp.Domain.Repositories.MemoryDb
+{
+    public class Utf8JsonMemoryDbSerializer : IMemoryDbSerializer, ITransientDependency
+    {
+        private readonly IJsonSerializer _jsonSerializer;
+
+        public Utf8JsonMemoryDbSerializer(IJsonSerializer jsonSerializer)
+        {
+            _jsonSerializer = jsonSerializer;
+        }
+
+        byte[] IMemoryDbSerializer.Serialize(object obj)
+        {
+            return Encoding.UTF8.GetBytes(_jsonSerializer.Serialize(obj));
+        }
+
+        public object Deserialize(byte[] value, Type type)
+        {
+            return _jsonSerializer.Deserialize(type, Encoding.UTF8.GetString(value));
+        }
+    }
+}

framework/src/Volo.Abp.MemoryDb/Volo/Abp/MemoryDb/AbpMemoryDbModule.cs

@@ -1,19 +1,19 @@
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Volo.Abp.Domain;
+using Volo.Abp.Domain.Repositories.MemoryDb;
+using Volo.Abp.Json;
 using Volo.Abp.Modularity;
 using Volo.Abp.Uow.MemoryDb;
 
 namespace Volo.Abp.MemoryDb
 {
-    /* TODO: Consider to store objects as binary serialized in the memory, which makes unit tests more realistic.
-     */
-
     [DependsOn(typeof(AbpDddDomainModule))]
     public class AbpMemoryDbModule : AbpModule
     {
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
             context.Services.TryAddTransient(typeof(IMemoryDatabaseProvider<>), typeof(UnitOfWorkMemoryDatabaseProvider<>));
+            context.Services.TryAddTransient(typeof(IMemoryDatabaseCollection<>), typeof(MemoryDatabaseCollection<>));
         }
     }
 }

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Uow/MemoryDb/UnitOfWorkMemoryDatabaseProvider.cs

@@ -11,15 +11,18 @@ namespace Volo.Abp.Uow.MemoryDb
         
         private readonly IUnitOfWorkManager _unitOfWorkManager;
         private readonly IConnectionStringResolver _connectionStringResolver;
+        private readonly MemoryDatabaseManager _memoryDatabaseManager;
 
         public UnitOfWorkMemoryDatabaseProvider(
             IUnitOfWorkManager unitOfWorkManager,
             IConnectionStringResolver connectionStringResolver,
-            TMemoryDbContext dbContext)
+            TMemoryDbContext dbContext, 
+            MemoryDatabaseManager memoryDatabaseManager)
         {
             _unitOfWorkManager = unitOfWorkManager;
             _connectionStringResolver = connectionStringResolver;
             DbContext = dbContext;
+            _memoryDatabaseManager = memoryDatabaseManager;
         }
 
         public IMemoryDatabase GetDatabase()
@@ -36,7 +39,7 @@ namespace Volo.Abp.Uow.MemoryDb
             var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                 dbContextKey,
                 () => new MemoryDbDatabaseApi(
-                    MemoryDatabaseManager.Get(connectionString)
+                    _memoryDatabaseManager.Get(connectionString)
                 ));
 
             return ((MemoryDbDatabaseApi)databaseApi).Database;

framework/test/Volo.Abp.TestApp/Volo/Abp/TestApp/Domain/City.cs

@@ -3,7 +3,6 @@ using Volo.Abp.Domain.Entities;
 
 namespace Volo.Abp.TestApp.Domain
 {
-    [Serializable]
     public class City : AggregateRoot<Guid>
     {
         public string Name { get; set; }

framework/test/Volo.Abp.TestApp/Volo/Abp/TestApp/Domain/Person.cs

@@ -7,7 +7,6 @@ using Volo.Abp.MultiTenancy;
 namespace Volo.Abp.TestApp.Domain
 {
     [AutoMapTo(typeof(PersonEto))]
-    [Serializable]
     public class Person : FullAuditedAggregateRoot<Guid>, IMultiTenant
     {
         public virtual Guid? TenantId { get; set; }

framework/test/Volo.Abp.TestApp/Volo/Abp/TestApp/Domain/Phone.cs

@@ -7,7 +7,6 @@ using Volo.Abp.Domain.Entities;
 namespace Volo.Abp.TestApp.Domain
 {
     [Table("AppPhones")]
-    [Serializable]
     public class Phone : Entity
     {
         public virtual Guid PersonId { get; set; }