diff --git a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/EasyMicroservices.Cores.AspCoreApi.csproj b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/EasyMicroservices.Cores.AspCoreApi.csproj
index b21819f..ed3534f 100644
--- a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/EasyMicroservices.Cores.AspCoreApi.csproj
+++ b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/EasyMicroservices.Cores.AspCoreApi.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Authors>EasyMicroservices</Authors>
-    <Version>0.0.0.64</Version>
+    <Version>0.0.0.65</Version>
     <Description>asp core servces.</Description>
     <Copyright>EasyMicroservices@gmail.com</Copyright>
     <PackageTags>core,cores,base,database,services,asp,aspnet</PackageTags>
diff --git a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/Interfaces/IReadableQueryServiceController.cs b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/Interfaces/IReadableQueryServiceController.cs
new file mode 100644
index 0000000..e745813
--- /dev/null
+++ b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/Interfaces/IReadableQueryServiceController.cs
@@ -0,0 +1,87 @@
+using EasyMicroservices.Cores.Contracts.Requests;
+using EasyMicroservices.Cores.Database.Interfaces;
+using EasyMicroservices.Cores.Interfaces;
+using EasyMicroservices.ServiceContracts;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+
+namespace EasyMicroservices.Cores.AspCoreApi.Interfaces;
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="TEntity"></typeparam>
+/// <typeparam name="TFilterContract"></typeparam>
+/// <typeparam name="TResponseContract"></typeparam>
+/// <typeparam name="TIdRequestContract"></typeparam>
+/// <typeparam name="TUniqueIdentityRequestContract"></typeparam>
+/// <typeparam name="TId"></typeparam>
+public interface IReadableQueryServiceController<TEntity, TFilterContract, TResponseContract, TId, TIdRequestContract, TUniqueIdentityRequestContract>
+        where TResponseContract : class
+        where TEntity : class
+        where TFilterContract : FilterRequestContract
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    protected IContractReadableLogic<TEntity, TResponseContract, TId> ContractLogic { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    protected IBaseUnitOfWork UnitOfWork { get; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public Task<MessageContract<TResponseContract>> GetById(TIdRequestContract request, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public Task<MessageContract<TResponseContract>> GetByUniqueIdentity(TUniqueIdentityRequestContract request, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="filterRequest"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public Task<ListMessageContract<TResponseContract>> Filter(TFilterContract filterRequest, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public Task<ListMessageContract<TResponseContract>> GetAll(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public Task<ListMessageContract<TResponseContract>> GetAllByUniqueIdentity(TUniqueIdentityRequestContract request, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    protected Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetQuery();
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    protected Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetAllQuery();
+}
diff --git a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/MultilingualReadableQueryServiceController.cs b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/MultilingualReadableQueryServiceController.cs
new file mode 100644
index 0000000..07753b1
--- /dev/null
+++ b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/MultilingualReadableQueryServiceController.cs
@@ -0,0 +1,244 @@
+using EasyMicroservices.Cores.AspCoreApi.Interfaces;
+using EasyMicroservices.Cores.Contracts.Requests;
+using EasyMicroservices.Cores.Contracts.Requests.Multilingual;
+using EasyMicroservices.Cores.Database.Interfaces;
+using EasyMicroservices.Cores.Interfaces;
+using EasyMicroservices.ServiceContracts;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+
+namespace EasyMicroservices.Cores.AspCoreApi;
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="TEntity"></typeparam>
+/// <typeparam name="TFilterContract"></typeparam>
+/// <typeparam name="TResponseContract"></typeparam>
+/// <typeparam name="TLanguageResponseContract"></typeparam>
+/// <typeparam name="TId"></typeparam>
+[ApiController]
+[Route("api/[controller]/[action]")]
+public class MultilingualReadableQueryServiceController<TEntity, TFilterContract, TResponseContract, TLanguageResponseContract, TId> :
+    ControllerBase, IReadableQueryServiceController<TEntity, TFilterContract, TResponseContract, TId, IdLanguageRequestContract<TId>, UniqueIdentityLanguageRequestContract>
+            where TResponseContract : class
+            where TLanguageResponseContract : class
+            where TEntity : class
+            where TFilterContract : FilterRequestContract
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public virtual IContractReadableLogic<TEntity, TResponseContract, TId> ContractLogic { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public virtual IBaseUnitOfWork UnitOfWork { get; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="contractReadable"></param>
+    public MultilingualReadableQueryServiceController(IContractReadableLogic<TEntity, TResponseContract, TId> contractReadable)
+    {
+        ContractLogic = contractReadable;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="unitOfWork"></param>
+    /// <param name="contractReadable"></param>
+    public MultilingualReadableQueryServiceController(IBaseUnitOfWork unitOfWork, IContractReadableLogic<TEntity, TResponseContract, TId> contractReadable)
+    {
+        ContractLogic = contractReadable;
+        UnitOfWork = unitOfWork;
+    }
+    /// <summary>
+    /// 
+    /// 
+    /// </summary>
+    /// <param name="unitOfWork"></param>
+    public MultilingualReadableQueryServiceController(IBaseUnitOfWork unitOfWork)
+    {
+        ContractLogic = unitOfWork.GetReadableContractLogic<TEntity, TResponseContract, TId>();
+    }
+
+    async Task<MessageContract<T>> ResolveContentLanguage<T>(MessageContract<T> result, string languageShortName)
+    {
+        if (!result)
+            return result;
+        var contentResolver = UnitOfWork.GetContentResolver();
+        await contentResolver.ResolveContentLanguage(result.Result, languageShortName);
+        return result;
+    }
+
+    async Task<ListMessageContract<T>> ResolveContentLanguage<T>(ListMessageContract<T> result, string languageShortName)
+    {
+        if (!result)
+            return result;
+        var contentResolver = UnitOfWork.GetContentResolver();
+        await contentResolver.ResolveContentLanguage(result.Result, languageShortName);
+        return result;
+    }
+
+    async Task<MessageContract<TLanguageResponseContract>> ResolveContentAllLanguage<T>(MessageContract<T> result)
+    {
+        if (!result)
+            return result.ToContract<TLanguageResponseContract>();
+        var contentResolver = UnitOfWork.GetContentResolver();
+        var mapper = UnitOfWork.GetMapper();
+        var mapped = mapper.Map<TLanguageResponseContract>(result.Result);
+        await contentResolver.ResolveContentAllLanguage(mapped);
+        return mapped;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public virtual async Task<MessageContract<TResponseContract>> GetById(IdLanguageRequestContract<TId> request, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetById(request, OnGetQuery(), cancellationToken);
+        return await ResolveContentLanguage(result, request.LanguageShortName);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public async Task<MessageContract<TLanguageResponseContract>> GetByIdAllLanguage(IdRequestContract<TId> request, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetById(request, OnGetQuery(), cancellationToken);
+        return await ResolveContentAllLanguage(result);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public virtual async Task<MessageContract<TResponseContract>> GetByUniqueIdentity(UniqueIdentityLanguageRequestContract request, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetByUniqueIdentity(request, request.Type, OnGetQuery(), cancellationToken);
+        return await ResolveContentLanguage(result, request.LanguageShortName);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public async Task<MessageContract<TLanguageResponseContract>> GetByUniqueIdentityAllLanguage(UniqueIdentityRequestContract request, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetByUniqueIdentity(request, request.Type, OnGetQuery(), cancellationToken);
+        return await ResolveContentAllLanguage(result);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="filterRequest"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public virtual async Task<ListMessageContract<TResponseContract>> Filter(TFilterContract filterRequest, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.Filter(filterRequest, OnGetAllQuery(), cancellationToken);
+        return await ResolveContentLanguage(result, filterRequest.LanguageShortName);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="filterRequest"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public async Task<MessageContract<TLanguageResponseContract>> FilterAllLanguage(TFilterContract filterRequest, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.Filter(filterRequest, OnGetAllQuery(), cancellationToken);
+        return await ResolveContentAllLanguage(result);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpGet]
+    public virtual async Task<ListMessageContract<TResponseContract>> GetAll(CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetAll(OnGetAllQuery(), cancellationToken);
+        return await ResolveContentLanguage(result, default);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public async Task<MessageContract<TLanguageResponseContract>> GetAllWithAllLanguage(CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetAll(OnGetAllQuery(), cancellationToken);
+        return await ResolveContentAllLanguage(result);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public virtual async Task<ListMessageContract<TResponseContract>> GetAllByUniqueIdentity(UniqueIdentityLanguageRequestContract request, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetAllByUniqueIdentity(request, request.Type, OnGetAllQuery(), cancellationToken);
+        return await ResolveContentLanguage(result, request.LanguageShortName);
+    }
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public async Task<MessageContract<TLanguageResponseContract>> GetAllByUniqueIdentityAllLanguage(UniqueIdentityRequestContract request, CancellationToken cancellationToken = default)
+    {
+        var result = await ContractLogic.GetAllByUniqueIdentity(request, request.Type, OnGetAllQuery(), cancellationToken);
+        return await ResolveContentAllLanguage(result);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    public virtual Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetQuery()
+    {
+        return null;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    public virtual Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetAllQuery()
+    {
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/MultilingualSimpleQueryServiceController.cs b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/MultilingualSimpleQueryServiceController.cs
new file mode 100644
index 0000000..e152a46
--- /dev/null
+++ b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/MultilingualSimpleQueryServiceController.cs
@@ -0,0 +1,291 @@
+using EasyMicroservices.Cores.Contracts.Requests;
+using EasyMicroservices.Cores.Database.Interfaces;
+using EasyMicroservices.Cores.Interfaces;
+using EasyMicroservices.ServiceContracts;
+using Microsoft.AspNetCore.Mvc;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EasyMicroservices.Cores.AspCoreApi;
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="TEntity"></typeparam>
+/// <typeparam name="TId"></typeparam>
+/// <typeparam name="TFilterRequestContract"></typeparam>
+/// <typeparam name="TCreateRequestContract"></typeparam>
+/// <typeparam name="TUpdateRequestContract"></typeparam>
+/// <typeparam name="TResponseContract"></typeparam>
+/// <typeparam name="TLanguageResponseContract"></typeparam>
+[ApiController]
+[Route("api/[controller]/[action]")]
+public class MultilingualSimpleQueryServiceController<TEntity, TFilterRequestContract, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TLanguageResponseContract, TId> : MultilingualReadableQueryServiceController<TEntity, TFilterRequestContract, TResponseContract, TLanguageResponseContract, TId>
+            where TResponseContract : class
+            where TLanguageResponseContract : class
+            where TEntity : class
+            where TFilterRequestContract : FilterRequestContract
+{
+    /// <summary>
+    /// 
+    /// 
+    /// </summary>
+    /// <param name="contractLogic"></param>
+    public MultilingualSimpleQueryServiceController(IContractLogic<TEntity, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TId> contractLogic) : base(contractLogic)
+    {
+    }
+
+    /// <summary>
+    /// 
+    /// 
+    /// </summary>
+    /// <param name="unitOfWork"></param>
+    public MultilingualSimpleQueryServiceController(IBaseUnitOfWork unitOfWork) : base(unitOfWork, unitOfWork.GetContractLogic<TEntity, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TId>())
+    {
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    protected virtual IContractLogic<TEntity, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TId> WritableContractLogic
+    {
+        get
+        {
+            return ContractLogic as IContractLogic<TEntity, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TId>;
+        }
+    }
+
+    string GetUniqueIdentity<T>(T item)
+    {
+        if (item is IUniqueIdentitySchema uniqueIdentitySchema)
+            return uniqueIdentitySchema.UniqueIdentity;
+        return (string)item.GetType()
+            .GetProperty(nameof(IUniqueIdentitySchema.UniqueIdentity), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
+            ?.GetValue(item, null);
+    }
+
+    void SetUniqueIdentity<T>(T item, string value)
+    {
+        if (item is IUniqueIdentitySchema uniqueIdentitySchema)
+            uniqueIdentitySchema.UniqueIdentity = value;
+        else
+            item.GetType()
+                .GetProperty(nameof(IUniqueIdentitySchema.UniqueIdentity), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
+                ?.SetValue(item, value);
+    }
+
+    async Task<MessageContract<TId>> AddToContentLanguage(MessageContract<TId> messageContract, params object[] requests)
+    {
+        if (!messageContract)
+            return messageContract;
+        var contentResolver = UnitOfWork.GetContentResolver();
+        var addedItem = await GetById(new Contracts.Requests.Multilingual.IdLanguageRequestContract<TId> { Id = messageContract })
+                    .AsCheckedResult();
+        foreach (var request in requests)
+        {
+            SetUniqueIdentity(request, GetUniqueIdentity(addedItem));
+        }
+        await contentResolver.AddToContentLanguage(requests);
+        return messageContract;
+    }
+
+    async Task<ListMessageContract<TId>> AddToContentLanguage(ListMessageContract<TId> messageContract, params object[] requests)
+    {
+        if (!messageContract)
+            return messageContract;
+        var contentResolver = UnitOfWork.GetContentResolver();
+        foreach (var item in messageContract.Result)
+        {
+            var addedItem = await GetById(new Contracts.Requests.Multilingual.IdLanguageRequestContract<TId> { Id = item })
+                    .AsCheckedResult();
+            foreach (var request in requests)
+            {
+                SetUniqueIdentity(request, GetUniqueIdentity(addedItem));
+            }
+        }
+        await contentResolver.AddToContentLanguage(requests);
+        return messageContract;
+    }
+
+    async Task<MessageContract<TResponseContract>> UpdateToContentLanguage(MessageContract<TResponseContract> messageContract, params object[] requests)
+    {
+        if (!messageContract)
+            return messageContract;
+        var contentResolver = UnitOfWork.GetContentResolver();
+        foreach (var request in requests)
+        {
+            SetUniqueIdentity(request, GetUniqueIdentity(messageContract.Result));
+        }
+        await contentResolver.UpdateToContentLanguage(requests);
+        return messageContract;
+    }
+
+    async Task<MessageContract> UpdateToContentLanguage(MessageContract messageContract, params object[] requests)
+    {
+        if (!messageContract)
+            return messageContract;
+        var contentResolver = UnitOfWork.GetContentResolver();
+        await contentResolver.UpdateToContentLanguage(requests.Where(x=> GetUniqueIdentity(x).HasValue()));
+        return messageContract;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public virtual async Task<MessageContract<TId>> Add(TCreateRequestContract request, CancellationToken cancellationToken = default)
+    {
+        var result = await WritableContractLogic.Add(request, cancellationToken);
+        return await AddToContentLanguage(result, request);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPost]
+    public virtual async Task<MessageContract> AddBulk(CreateBulkRequestContract<TCreateRequestContract> request, CancellationToken cancellationToken = default)
+    {
+        var result = await WritableContractLogic.AddBulk(request, cancellationToken);
+        return await AddToContentLanguage(result, request);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPut]
+    public virtual async Task<MessageContract<TResponseContract>> Update(TUpdateRequestContract request, CancellationToken cancellationToken = default)
+    {
+        var result = await WritableContractLogic.Update(request, cancellationToken);
+        return await UpdateToContentLanguage(result, request);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPut]
+    public virtual async Task<MessageContract<TResponseContract>> UpdateChangedValuesOnly(TUpdateRequestContract request, CancellationToken cancellationToken = default)
+    {
+        var result = await WritableContractLogic.UpdateChangedValuesOnly(request, cancellationToken);
+        return await UpdateToContentLanguage(result, request);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPut]
+    public virtual async Task<MessageContract> UpdateBulk(UpdateBulkRequestContract<TUpdateRequestContract> request, CancellationToken cancellationToken = default)
+    {
+        var result = await WritableContractLogic.UpdateBulk(request, cancellationToken);
+        return await UpdateToContentLanguage(result, request.Items);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpPut]
+    public virtual async Task<MessageContract> UpdateBulkChangedValuesOnly(UpdateBulkRequestContract<TUpdateRequestContract> request, CancellationToken cancellationToken = default)
+    {
+        var result = await WritableContractLogic.UpdateBulk(request, cancellationToken);
+        return await UpdateToContentLanguage(result, request.Items);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpDelete]
+    public virtual Task<MessageContract> HardDeleteById(DeleteRequestContract<TId> request, CancellationToken cancellationToken = default)
+    {
+        return WritableContractLogic.HardDeleteById(request, cancellationToken);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpDelete]
+    public virtual Task<MessageContract> HardDeleteBulkByIds(DeleteBulkRequestContract<TId> request, CancellationToken cancellationToken = default)
+    {
+        return WritableContractLogic.HardDeleteBulkByIds(request, cancellationToken);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpDelete]
+    public virtual Task<MessageContract> SoftDeleteById(SoftDeleteRequestContract<TId> request, CancellationToken cancellationToken = default)
+    {
+        return WritableContractLogic.SoftDeleteById(request, cancellationToken);
+    }
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    [HttpDelete]
+    public virtual Task<MessageContract> SoftDeleteBulkByIds(SoftDeleteBulkRequestContract<TId> request, CancellationToken cancellationToken = default)
+    {
+        return WritableContractLogic.SoftDeleteBulkByIds(request, cancellationToken);
+    }
+}
+
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="TEntity"></typeparam>
+/// <typeparam name="TId"></typeparam>
+/// <typeparam name="TCreateRequestContract"></typeparam>
+/// <typeparam name="TUpdateRequestContract"></typeparam>
+/// <typeparam name="TResponseContract"></typeparam>
+/// <typeparam name="TLanguageResponseContract"></typeparam>
+[ApiController]
+[Route("api/[controller]/[action]")]
+public class MultilingualSimpleQueryServiceController<TEntity, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TLanguageResponseContract, TId> : MultilingualSimpleQueryServiceController<TEntity, FilterRequestContract, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TLanguageResponseContract, TId>
+    where TResponseContract : class
+    where TLanguageResponseContract : class
+    where TEntity : class
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="contractLogic"></param>
+    public MultilingualSimpleQueryServiceController(IContractLogic<TEntity, TCreateRequestContract, TUpdateRequestContract, TResponseContract, TId> contractLogic) : base(contractLogic)
+    {
+    }
+
+    /// <summary>
+    /// 
+    /// 
+    /// </summary>
+    /// <param name="unitOfWork"></param>
+    public MultilingualSimpleQueryServiceController(IBaseUnitOfWork unitOfWork) : base(unitOfWork)
+    {
+    }
+}
\ No newline at end of file
diff --git a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/ReadableQueryServiceController.cs b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/ReadableQueryServiceController.cs
index f507a85..15ff1d9 100644
--- a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/ReadableQueryServiceController.cs
+++ b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/ReadableQueryServiceController.cs
@@ -1,4 +1,5 @@
-using EasyMicroservices.Cores.Contracts.Requests;
+using EasyMicroservices.Cores.AspCoreApi.Interfaces;
+using EasyMicroservices.Cores.Contracts.Requests;
 using EasyMicroservices.Cores.Database.Interfaces;
 using EasyMicroservices.Cores.Interfaces;
 using EasyMicroservices.ServiceContracts;
@@ -19,20 +20,22 @@ namespace EasyMicroservices.Cores.AspCoreApi
     /// <typeparam name="TId"></typeparam>
     [ApiController]
     [Route("api/[controller]/[action]")]
-    public class ReadableQueryServiceController<TEntity, TFilterContract, TResponseContract, TId> : ControllerBase
-        where TResponseContract : class
-        where TEntity : class
-        where TFilterContract : FilterRequestContract
+    public class ReadableQueryServiceController<TEntity, TFilterContract, TResponseContract, TId> :
+        ControllerBase, IReadableQueryServiceController<TEntity, TFilterContract, TResponseContract, TId, IdRequestContract<TId>, UniqueIdentityRequestContract>
+            where TResponseContract : class
+            where TEntity : class
+            where TFilterContract : FilterRequestContract
     {
         /// <summary>
         /// 
         /// </summary>
-        protected virtual IContractReadableLogic<TEntity, TResponseContract, TId> ContractLogic { get; private set; }
+        public virtual IContractReadableLogic<TEntity, TResponseContract, TId> ContractLogic { get; set; }
 
         /// <summary>
         /// 
         /// </summary>
-        protected virtual IBaseUnitOfWork UnitOfWork { get; }
+        public virtual IBaseUnitOfWork UnitOfWork { get; }
+
         /// <summary>
         /// 
         /// </summary>
@@ -68,7 +71,7 @@ public ReadableQueryServiceController(IBaseUnitOfWork unitOfWork)
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         [HttpPost]
-        public virtual Task<MessageContract<TResponseContract>> GetById(GetIdRequestContract<TId> request, CancellationToken cancellationToken = default)
+        public virtual Task<MessageContract<TResponseContract>> GetById(IdRequestContract<TId> request, CancellationToken cancellationToken = default)
         {
             return ContractLogic.GetById(request, OnGetQuery(), cancellationToken);
         }
@@ -80,7 +83,7 @@ public virtual Task<MessageContract<TResponseContract>> GetById(GetIdRequestCont
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         [HttpPost]
-        public virtual Task<MessageContract<TResponseContract>> GetByUniqueIdentity(GetUniqueIdentityRequestContract request, CancellationToken cancellationToken = default)
+        public virtual Task<MessageContract<TResponseContract>> GetByUniqueIdentity(UniqueIdentityRequestContract request, CancellationToken cancellationToken = default)
         {
             return ContractLogic.GetByUniqueIdentity(request, request.Type, OnGetQuery(), cancellationToken);
         }
@@ -115,7 +118,7 @@ public virtual Task<ListMessageContract<TResponseContract>> GetAll(CancellationT
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         [HttpPost]
-        public virtual Task<ListMessageContract<TResponseContract>> GetAllByUniqueIdentity(GetUniqueIdentityRequestContract request, CancellationToken cancellationToken = default)
+        public virtual Task<ListMessageContract<TResponseContract>> GetAllByUniqueIdentity(UniqueIdentityRequestContract request, CancellationToken cancellationToken = default)
         {
             return ContractLogic.GetAllByUniqueIdentity(request, request.Type, OnGetAllQuery(), cancellationToken);
         }
@@ -124,7 +127,7 @@ public virtual Task<ListMessageContract<TResponseContract>> GetAllByUniqueIdenti
         /// 
         /// </summary>
         /// <returns></returns>
-        protected virtual Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetQuery()
+        public virtual Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetQuery()
         {
             return null;
         }
@@ -133,7 +136,7 @@ protected virtual Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetQuery()
         /// 
         /// </summary>
         /// <returns></returns>
-        protected virtual Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetAllQuery()
+        public virtual Func<IQueryable<TEntity>, IQueryable<TEntity>> OnGetAllQuery()
         {
             return null;
         }
diff --git a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/SimpleQueryServiceController.cs b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/SimpleQueryServiceController.cs
index 520edfc..726f3d0 100644
--- a/src/CSharp/EasyMicroservices.Cores.AspCoreApi/SimpleQueryServiceController.cs
+++ b/src/CSharp/EasyMicroservices.Cores.AspCoreApi/SimpleQueryServiceController.cs
@@ -74,7 +74,7 @@ public virtual Task<MessageContract<TId>> Add(TCreateRequestContract request, Ca
         [HttpPost]
         public virtual Task<MessageContract> AddBulk(CreateBulkRequestContract<TCreateRequestContract> request, CancellationToken cancellationToken = default)
         {
-            return WritableContractLogic.AddBulk(request, cancellationToken);
+            return WritableContractLogic.AddBulk(request, cancellationToken).ToContract();
         }
 
         /// <summary>
diff --git a/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/EasyMicroservices.Cores.AspEntityFrameworkCoreApi.csproj b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/EasyMicroservices.Cores.AspEntityFrameworkCoreApi.csproj
index 6d4c7a6..2786b6b 100644
--- a/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/EasyMicroservices.Cores.AspEntityFrameworkCoreApi.csproj
+++ b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/EasyMicroservices.Cores.AspEntityFrameworkCoreApi.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Authors>EasyMicroservices</Authors>
-    <Version>0.0.0.64</Version>
+    <Version>0.0.0.65</Version>
     <Description>asp core servces.</Description>
     <Copyright>EasyMicroservices@gmail.com</Copyright>
     <PackageTags>core,cores,base,database,services,asp,aspnet,aspcore,efcore</PackageTags>
@@ -20,8 +20,9 @@
     <PackageReference Include="EasyMicroservices.Mapper.CompileTimeMapper" Version="*" />
     <PackageReference Include="EasyMicroservices.Serialization.Newtonsoft.Json" Version="*" />
     <PackageReference Include="EasyMicroservices.Mapper.SerializerMapper" Version="*" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="*" />
     <PackageReference Include="EasyMicroservices.WhiteLabelsMicroservice.Clients" Version="*" />
+    <PackageReference Include="EasyMicroservices.ContentsMicroservice.Clients" Version="*" />
   </ItemGroup>
   
   <ItemGroup Condition=" '$(TargetFramework)' == 'net7.0' ">
diff --git a/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/InternalContentResolver.cs b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/InternalContentResolver.cs
new file mode 100644
index 0000000..c13925c
--- /dev/null
+++ b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/InternalContentResolver.cs
@@ -0,0 +1,37 @@
+using EasyMicroservices.ContentsMicroservice.Clients.Helpers;
+using EasyMicroservices.Cores.Interfaces;
+using EasyMicroservices.ServiceContracts;
+using System;
+using System.Collections;
+using System.Threading.Tasks;
+
+namespace EasyMicroservices.Cores.AspEntityFrameworkCoreApi;
+internal class InternalContentResolver : IContentResolver
+{
+    readonly ContentLanguageHelper _contentLanguageHelper;
+    public InternalContentResolver(ContentLanguageHelper contentLanguageHelper)
+    {
+        _contentLanguageHelper = contentLanguageHelper;
+    }
+
+    public Task AddToContentLanguage(params object[] item)
+    {
+        return _contentLanguageHelper.AddToContentLanguage(item)
+            .AsCheckedResult();
+    }
+
+    public Task ResolveContentAllLanguage(object contract)
+    {
+        return _contentLanguageHelper.ResolveContentAllLanguage(contract);
+    }
+
+    public Task ResolveContentLanguage(object contract, string language)
+    {
+        return _contentLanguageHelper.ResolveContentLanguage(contract, language);
+    }
+
+    public Task UpdateToContentLanguage(params object[] item)
+    {
+        return _contentLanguageHelper.UpdateToContentLanguage(item);
+    }
+}
diff --git a/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/StartUpExtensions.cs b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/StartUpExtensions.cs
index c01569c..690d683 100644
--- a/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/StartUpExtensions.cs
+++ b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/StartUpExtensions.cs
@@ -1,4 +1,5 @@
-using EasyMicroservices.Cores.AspCoreApi.Authorizations;
+using EasyMicroservices.ContentsMicroservice.Clients.Helpers;
+using EasyMicroservices.Cores.AspCoreApi.Authorizations;
 using EasyMicroservices.Cores.AspCoreApi.Interfaces;
 using EasyMicroservices.Cores.AspCoreApi.Managers;
 using EasyMicroservices.Cores.AspEntityFrameworkCoreApi.Interfaces;
@@ -20,6 +21,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -79,6 +81,9 @@ public static IServiceCollection Builder<TContext>(this IServiceCollection servi
             {
                 option.ExceptionHandler = AppAuthorizationMiddleware.ExceptionHandler;
             });
+            services.AddSingleton<Contents.GeneratedServices.ContentClient>(service => new Contents.GeneratedServices.ContentClient(service.GetService<IConfiguration>().GetValue<string>("RootAddresses:Content"), new HttpClient()));
+            services.AddSingleton<ContentLanguageHelper>();
+            services.AddSingleton<IContentResolver, InternalContentResolver>();
             return services;
         }
 
diff --git a/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/UnitOfWork.cs b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/UnitOfWork.cs
index 619cc30..a9c3306 100644
--- a/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/UnitOfWork.cs
+++ b/src/CSharp/EasyMicroservices.Cores.AspEntityFrameworkCoreApi/UnitOfWork.cs
@@ -3,6 +3,7 @@
 using EasyMicroservices.Cores.AspEntityFrameworkCoreApi.Interfaces;
 using EasyMicroservices.Cores.Database.Interfaces;
 using EasyMicroservices.Cores.Database.Logics;
+using EasyMicroservices.Cores.Interfaces;
 using EasyMicroservices.Cores.Models;
 using EasyMicroservices.Cores.Relational.EntityFrameworkCore;
 using EasyMicroservices.Database.EntityFrameworkCore.Providers;
@@ -66,6 +67,16 @@ public virtual IDatabase GetDatabase()
             return AddDisposable(new EntityFrameworkCoreDatabaseProvider(context));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public IContentResolver GetContentResolver()
+        {
+            return ServiceProvider.GetService<IContentResolver>();
+        }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/CSharp/EasyMicroservices.Cores.Clients/EasyMicroservices.Cores.Clients.csproj b/src/CSharp/EasyMicroservices.Cores.Clients/EasyMicroservices.Cores.Clients.csproj
index b2324a6..083250b 100644
--- a/src/CSharp/EasyMicroservices.Cores.Clients/EasyMicroservices.Cores.Clients.csproj
+++ b/src/CSharp/EasyMicroservices.Cores.Clients/EasyMicroservices.Cores.Clients.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0;net8.0</TargetFrameworks>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Authors>EasyMicroservices</Authors>
-    <Version>0.0.0.64</Version>
+    <Version>0.0.0.65</Version>
     <Description>core of database.</Description>
     <Copyright>EasyMicroservices@gmail.com</Copyright>
     <PackageTags>core,cores,base,client,clients</PackageTags>
diff --git a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/FilterRequestContract.cs b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/FilterRequestContract.cs
index f07f006..30a8765 100644
--- a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/FilterRequestContract.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/FilterRequestContract.cs
@@ -67,6 +67,6 @@ public class FilterRequestContract
         /// <summary>
         /// en-US, fa-IR
         /// </summary>
-        public string Language { get; set; }
+        public string LanguageShortName { get; set; }
     }
 }
diff --git a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/GetIdRequestContract.cs b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/IdRequestContract.cs
similarity index 72%
rename from src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/GetIdRequestContract.cs
rename to src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/IdRequestContract.cs
index d582d13..a8dabf0 100644
--- a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/GetIdRequestContract.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/IdRequestContract.cs
@@ -6,7 +6,7 @@ namespace EasyMicroservices.Cores.Contracts.Requests
     /// 
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class GetIdRequestContract<T> : IIdSchema<T>
+    public class IdRequestContract<T> : IIdSchema<T>
     {
         /// <summary>
         /// 
@@ -16,9 +16,9 @@ public class GetIdRequestContract<T> : IIdSchema<T>
         /// 
         /// </summary>
         /// <param name="id"></param>
-        public static implicit operator GetIdRequestContract<T>(T id)
+        public static implicit operator IdRequestContract<T>(T id)
         {
-            return new GetIdRequestContract<T>()
+            return new IdRequestContract<T>()
             {
                 Id = id
             };
diff --git a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/Multilingual/IdLanguageRequestContract.cs b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/Multilingual/IdLanguageRequestContract.cs
new file mode 100644
index 0000000..9c1ee14
--- /dev/null
+++ b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/Multilingual/IdLanguageRequestContract.cs
@@ -0,0 +1,36 @@
+namespace EasyMicroservices.Cores.Contracts.Requests.Multilingual;
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public class IdLanguageRequestContract<T> : IdRequestContract<T>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public string LanguageShortName { get; set; }
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="id"></param>
+    public static implicit operator IdLanguageRequestContract<T>(T id)
+    {
+        return new IdLanguageRequestContract<T>()
+        {
+            Id = id
+        };
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="input"></param>
+    public static implicit operator IdLanguageRequestContract<T>((T Id, string LanguageShortName) input)
+    {
+        return new IdLanguageRequestContract<T>()
+        {
+            Id = input.Id,
+            LanguageShortName = input.LanguageShortName
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/Multilingual/UniqueIdentityLanguageRequestContract.cs b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/Multilingual/UniqueIdentityLanguageRequestContract.cs
new file mode 100644
index 0000000..d2338c5
--- /dev/null
+++ b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/Multilingual/UniqueIdentityLanguageRequestContract.cs
@@ -0,0 +1,36 @@
+namespace EasyMicroservices.Cores.Contracts.Requests.Multilingual;
+/// <summary>
+/// 
+/// </summary>
+public class UniqueIdentityLanguageRequestContract : UniqueIdentityRequestContract
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public string LanguageShortName { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uniqueIdentity"></param>
+    public static implicit operator UniqueIdentityLanguageRequestContract(string uniqueIdentity)
+    {
+        return new UniqueIdentityLanguageRequestContract()
+        {
+            UniqueIdentity = uniqueIdentity
+        };
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="input"></param>
+    public static implicit operator UniqueIdentityLanguageRequestContract((string UniqueIdentity, string LanguageShortName) input)
+    {
+        return new UniqueIdentityLanguageRequestContract()
+        {
+            UniqueIdentity = input.UniqueIdentity,
+            LanguageShortName = input.LanguageShortName
+        };
+    }
+}
diff --git a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/GetUniqueIdentityRequestContract.cs b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/UniqueIdentityRequestContract.cs
similarity index 77%
rename from src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/GetUniqueIdentityRequestContract.cs
rename to src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/UniqueIdentityRequestContract.cs
index d7cab7b..1467a11 100644
--- a/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/GetUniqueIdentityRequestContract.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Contracts/Contracts/Requests/UniqueIdentityRequestContract.cs
@@ -6,7 +6,7 @@ namespace EasyMicroservices.Cores.Contracts.Requests
     /// <summary>
     /// 
     /// </summary>
-    public class GetUniqueIdentityRequestContract : IUniqueIdentitySchema
+    public class UniqueIdentityRequestContract : IUniqueIdentitySchema
     {
         /// <summary>
         /// 
@@ -21,9 +21,9 @@ public class GetUniqueIdentityRequestContract : IUniqueIdentitySchema
         /// 
         /// </summary>
         /// <param name="uniqueIdentity"></param>
-        public static implicit operator GetUniqueIdentityRequestContract(string uniqueIdentity)
+        public static implicit operator UniqueIdentityRequestContract(string uniqueIdentity)
         {
-            return new GetUniqueIdentityRequestContract()
+            return new UniqueIdentityRequestContract()
             {
                 UniqueIdentity = uniqueIdentity
             };
diff --git a/src/CSharp/EasyMicroservices.Cores.Contracts/EasyMicroservices.Cores.Contracts.csproj b/src/CSharp/EasyMicroservices.Cores.Contracts/EasyMicroservices.Cores.Contracts.csproj
index 744386d..4f96b19 100644
--- a/src/CSharp/EasyMicroservices.Cores.Contracts/EasyMicroservices.Cores.Contracts.csproj
+++ b/src/CSharp/EasyMicroservices.Cores.Contracts/EasyMicroservices.Cores.Contracts.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>netstandard2.0;netstandard2.1;net45;net6.0;net8.0</TargetFrameworks>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Authors>EasyMicroservices</Authors>
-    <Version>0.0.0.64</Version>
+    <Version>0.0.0.65</Version>
     <Description>core contracts.</Description>
     <Copyright>EasyMicroservices@gmail.com</Copyright>
     <PackageTags>core,cores,base,contract,contracts,dto,dtos</PackageTags>
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IReadableLogic.cs b/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IReadableLogic.cs
index 86d1605..9efb84a 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IReadableLogic.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IReadableLogic.cs
@@ -24,7 +24,7 @@ public interface IReadableLogic<TResultSchema, TId>
         /// <param name="idRequest"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        Task<MessageContract<TResultSchema>> GetById(GetIdRequestContract<TId> idRequest, CancellationToken cancellationToken = default);
+        Task<MessageContract<TResultSchema>> GetById(IdRequestContract<TId> idRequest, CancellationToken cancellationToken = default);
         /// <summary>
         /// 
         /// </summary>
@@ -64,7 +64,7 @@ public interface IContractReadableLogic<TEntity, TContract, TId> : IReadableLogi
         /// <param name="query"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        Task<MessageContract<TContract>> GetById(GetIdRequestContract<TId> idRequest, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default);
+        Task<MessageContract<TContract>> GetById(IdRequestContract<TId> idRequest, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default);
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IWritableLogic.cs b/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IWritableLogic.cs
index a9476f6..e9dde22 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IWritableLogic.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Database/Interfaces/IWritableLogic.cs
@@ -94,7 +94,7 @@ public interface IContractWritableLogic<TEntity, TCreateContract, TContract, TUp
         /// <param name="request"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        Task<MessageContract> AddBulk(CreateBulkRequestContract<TCreateContract> request, CancellationToken cancellationToken = default);
+        Task<ListMessageContract<TId>> AddBulk(CreateBulkRequestContract<TCreateContract> request, CancellationToken cancellationToken = default);
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicBase.cs b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicBase.cs
index abb284b..e0a604e 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicBase.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicBase.cs
@@ -61,7 +61,7 @@ public DatabaseLogicBase(IEasyReadableQueryableAsync<TEntity> easyReadableQuerya
         /// <param name="idRequest"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task<MessageContract<TEntity>> GetById(GetIdRequestContract<TId> idRequest, CancellationToken cancellationToken = default)
+        public async Task<MessageContract<TEntity>> GetById(IdRequestContract<TId> idRequest, CancellationToken cancellationToken = default)
         {
             return await GetById(_easyReadableQueryable, idRequest, null, cancellationToken);
         }
@@ -73,7 +73,7 @@ public async Task<MessageContract<TEntity>> GetById(GetIdRequestContract<TId> id
         /// <param name="query"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task<MessageContract<TEntity>> GetById(GetIdRequestContract<TId> idRequest, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default)
+        public async Task<MessageContract<TEntity>> GetById(IdRequestContract<TId> idRequest, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default)
         {
             Func<IEasyReadableQueryableAsync<TEntity>, IEasyReadableQueryableAsync<TEntity>> func = null;
             if (query != null)
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicInfrastructure.cs b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicInfrastructure.cs
index da6d24f..6531863 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicInfrastructure.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseLogicInfrastructure.cs
@@ -103,7 +103,7 @@ private async Task<IEasyReadableQueryableAsync<TEntity>> UniqueIdentityQueryMake
         /// <param name="query"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        protected async Task<MessageContract<TEntity>> GetById<TEntity, TId>(IEasyReadableQueryableAsync<TEntity> easyReadableQueryable, GetIdRequestContract<TId> idRequest, Func<IEasyReadableQueryableAsync<TEntity>, IEasyReadableQueryableAsync<TEntity>> query = default, CancellationToken cancellationToken = default)
+        protected async Task<MessageContract<TEntity>> GetById<TEntity, TId>(IEasyReadableQueryableAsync<TEntity> easyReadableQueryable, IdRequestContract<TId> idRequest, Func<IEasyReadableQueryableAsync<TEntity>, IEasyReadableQueryableAsync<TEntity>> query = default, CancellationToken cancellationToken = default)
             where TEntity : class
         {
             IEasyReadableQueryableAsync<TEntity> queryable = easyReadableQueryable;
@@ -230,7 +230,7 @@ public async Task<MessageContract<TContract>> GetBy<TEntity, TContract>(IEasyRea
         /// <param name="query"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        protected async Task<MessageContract<TContract>> GetById<TEntity, TContract, TId>(IEasyReadableQueryableAsync<TEntity> easyReadableQueryable, GetIdRequestContract<TId> idRequest, Func<IEasyReadableQueryableAsync<TEntity>, IEasyReadableQueryableAsync<TEntity>> query = default, CancellationToken cancellationToken = default)
+        protected async Task<MessageContract<TContract>> GetById<TEntity, TContract, TId>(IEasyReadableQueryableAsync<TEntity> easyReadableQueryable, IdRequestContract<TId> idRequest, Func<IEasyReadableQueryableAsync<TEntity>, IEasyReadableQueryableAsync<TEntity>> query = default, CancellationToken cancellationToken = default)
             where TEntity : class
             where TContract : class
         {
@@ -762,7 +762,7 @@ public async Task<MessageContract<TEntity>> Add<TEntity>(IEasyWritableQueryableA
         /// <param name="entities"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task<MessageContract> AddBulk<TEntity>(IEasyWritableQueryableAsync<TEntity> easyWritableQueryable, IEnumerable<TEntity> entities, CancellationToken cancellationToken = default)
+        public async Task<ListMessageContract<TEntity>> AddBulk<TEntity>(IEasyWritableQueryableAsync<TEntity> easyWritableQueryable, IEnumerable<TEntity> entities, CancellationToken cancellationToken = default)
             where TEntity : class
         {
             var result = await easyWritableQueryable.AddBulkAsync(entities, cancellationToken);
@@ -793,7 +793,7 @@ public async Task<MessageContract> AddBulk<TEntity>(IEasyWritableQueryableAsync<
                 await InternalUpdateBulk(easyWritableQueryable, result.Select(x => x.Entity).ToList(), false, true, true, cancellationToken);
                 await easyWritableQueryable.SaveChangesAsync();
             }
-            return true;
+            return result.Select(x => x.Entity).ToList();
         }
 
         /// <summary>
@@ -822,7 +822,7 @@ public async Task<MessageContract<TEntity>> Add<TEntity, TContract>(IEasyWritabl
         /// <param name="request"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task<MessageContract> AddBulk<TEntity, TContract>(IEasyWritableQueryableAsync<TEntity> easyWritableQueryable, CreateBulkRequestContract<TContract> request, CancellationToken cancellationToken = default)
+        public async Task<ListMessageContract<TEntity>> AddBulk<TEntity, TContract>(IEasyWritableQueryableAsync<TEntity> easyWritableQueryable, CreateBulkRequestContract<TContract> request, CancellationToken cancellationToken = default)
            where TEntity : class
         {
             var entities = await MapToListAsync<TEntity, TContract>(request.Items);
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseMappedLogicBase.cs b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseMappedLogicBase.cs
index 8c9a808..d756339 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseMappedLogicBase.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/DatabaseMappedLogicBase.cs
@@ -3,9 +3,9 @@
 using EasyMicroservices.Cores.DataTypes;
 using EasyMicroservices.Cores.Interfaces;
 using EasyMicroservices.Database.Interfaces;
-using EasyMicroservices.Mapper.Interfaces;
 using EasyMicroservices.ServiceContracts;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
@@ -76,7 +76,7 @@ public async Task<ListMessageContract<TResponseContract>> GetAll(CancellationTok
         /// <param name="query"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public virtual Task<MessageContract<TResponseContract>> GetById(GetIdRequestContract<TResponseContract> contract, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default)
+        public virtual Task<MessageContract<TResponseContract>> GetById(IdRequestContract<TResponseContract> contract, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default)
         {
             throw new Exception("GetById is not supported in DatabaseMappedLogicBase, you can use IdSchemaDatabaseMappedLogicBase or override this GetById method");
         }
@@ -119,10 +119,14 @@ public async Task<MessageContract<TResponseContract>> Add(TCreateRequestContract
         /// <param name="request"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task<MessageContract> AddBulk(CreateBulkRequestContract<TCreateRequestContract> request, CancellationToken cancellationToken = default)
+        public async Task<ListMessageContract<TResponseContract>> AddBulk(CreateBulkRequestContract<TCreateRequestContract> request, CancellationToken cancellationToken = default)
         {
-            var result = await Add(_easyWriteableQueryable, request, cancellationToken);
-            return result;
+            var result = await AddBulk(_easyWriteableQueryable, request, cancellationToken);
+            if (!result)
+                return result.ToListContract<TResponseContract>();
+            var mapped = await MapAsync<List<TResponseContract>, List<TEntity>>(result.Result);
+            ValidateMappedResult(ref mapped);
+            return mapped;
         }
 
         /// <summary>
@@ -186,7 +190,7 @@ public async Task<ListMessageContract<TResponseContract>> GetAll(Func<IQueryable
         /// <param name="contract"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public Task<MessageContract<TResponseContract>> GetById(GetIdRequestContract<TResponseContract> contract, CancellationToken cancellationToken = default)
+        public Task<MessageContract<TResponseContract>> GetById(IdRequestContract<TResponseContract> contract, CancellationToken cancellationToken = default)
         {
             throw new Exception("GetById is not supported in DatabaseMappedLogicBase, you can use IdSchemaDatabaseMappedLogicBase or override this GetById method");
         }
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/IdSchemaDatabaseMappedLogicBase.cs b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/IdSchemaDatabaseMappedLogicBase.cs
index 3a04e71..baddd71 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/IdSchemaDatabaseMappedLogicBase.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Database/Logics/IdSchemaDatabaseMappedLogicBase.cs
@@ -3,9 +3,9 @@
 using EasyMicroservices.Cores.DataTypes;
 using EasyMicroservices.Cores.Interfaces;
 using EasyMicroservices.Database.Interfaces;
-using EasyMicroservices.Mapper.Interfaces;
 using EasyMicroservices.ServiceContracts;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
@@ -77,7 +77,7 @@ public async Task<ListMessageContract<TResponseContract>> GetAll(CancellationTok
         /// <param name="query"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task<MessageContract<TResponseContract>> GetById(GetIdRequestContract<TId> idRequest, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default)
+        public async Task<MessageContract<TResponseContract>> GetById(IdRequestContract<TId> idRequest, Func<IQueryable<TEntity>, IQueryable<TEntity>> query = default, CancellationToken cancellationToken = default)
         {
             Func<IEasyReadableQueryableAsync<TEntity>, IEasyReadableQueryableAsync<TEntity>> func = UpdateFunctionQuery(query);
             return await GetById<TEntity, TResponseContract, TId>(_easyReadableQueryable, idRequest, func, cancellationToken);
@@ -122,9 +122,22 @@ public async Task<MessageContract<TId>> Add(TCreateRequestContract contract, Can
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         /// <exception cref="NotImplementedException"></exception>
-        public Task<MessageContract> AddBulk(CreateBulkRequestContract<TCreateRequestContract> request, CancellationToken cancellationToken = default)
+        public async Task<ListMessageContract<TId>> AddBulk(CreateBulkRequestContract<TCreateRequestContract> request, CancellationToken cancellationToken = default)
         {
-            return AddBulk(_easyWriteableQueryable, request, cancellationToken);
+            var result = await AddBulk(_easyWriteableQueryable, request, cancellationToken);
+            if (result)
+            {
+                List<TId> items = new List<TId>();
+                foreach (var item in result.Result)
+                {
+                    if (item is IIdSchema<TId> schema)
+                        items.Add(schema.Id);
+                    else
+                        items.Add(MapperProvider.Map<TId>(item));
+                }
+                return items;
+            }
+            return result.ToListContract<TId>();
         }
 
         /// <summary>
@@ -182,7 +195,7 @@ public Task<ListMessageContract<TResponseContract>> Filter(FilterRequestContract
         /// <param name="idRequest"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public Task<MessageContract<TResponseContract>> GetById(GetIdRequestContract<TId> idRequest, CancellationToken cancellationToken = default)
+        public Task<MessageContract<TResponseContract>> GetById(IdRequestContract<TId> idRequest, CancellationToken cancellationToken = default)
         {
             return GetById<TEntity, TResponseContract, TId>(_easyReadableQueryable, idRequest, null, cancellationToken);
         }
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/EasyMicroservices.Cores.Database.csproj b/src/CSharp/EasyMicroservices.Cores.Database/EasyMicroservices.Cores.Database.csproj
index 930783b..dbfc2ac 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/EasyMicroservices.Cores.Database.csproj
+++ b/src/CSharp/EasyMicroservices.Cores.Database/EasyMicroservices.Cores.Database.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>netstandard2.0;netstandard2.1;net45;net6.0;net8.0</TargetFrameworks>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Authors>EasyMicroservices</Authors>
-    <Version>0.0.0.64</Version>
+    <Version>0.0.0.65</Version>
     <Description>core of database.</Description>
     <Copyright>EasyMicroservices@gmail.com</Copyright>
     <PackageTags>core,cores,base,database</PackageTags>
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Interfaces/IBaseUnitOfWork.cs b/src/CSharp/EasyMicroservices.Cores.Database/Interfaces/IBaseUnitOfWork.cs
index c3c22d3..0526f2a 100644
--- a/src/CSharp/EasyMicroservices.Cores.Database/Interfaces/IBaseUnitOfWork.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Interfaces/IBaseUnitOfWork.cs
@@ -38,6 +38,11 @@ public interface IBaseUnitOfWork : IDisposable
         /// <summary>
         /// 
         /// </summary>
+        /// <returns></returns>
+        IContentResolver GetContentResolver();
+        /// <summary>
+        /// 
+        /// </summary>
         /// <typeparam name="TEntity"></typeparam>
         /// <returns></returns>
         IContractLogic<TEntity, TEntity, TEntity, TEntity, long> GetLongLogic<TEntity>()
diff --git a/src/CSharp/EasyMicroservices.Cores.Database/Interfaces/IContentResolver.cs b/src/CSharp/EasyMicroservices.Cores.Database/Interfaces/IContentResolver.cs
new file mode 100644
index 0000000..1351726
--- /dev/null
+++ b/src/CSharp/EasyMicroservices.Cores.Database/Interfaces/IContentResolver.cs
@@ -0,0 +1,36 @@
+using EasyMicroservices.ServiceContracts;
+using System.Collections;
+using System.Threading.Tasks;
+
+namespace EasyMicroservices.Cores.Interfaces;
+/// <summary>
+/// 
+/// </summary>
+public interface IContentResolver
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="contract"></param>
+    /// <param name="language"></param>
+    /// <returns></returns>
+    Task ResolveContentLanguage(object contract, string language);
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="item"></param>
+    /// <returns></returns>
+    Task AddToContentLanguage(params object[] item);
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="item"></param>
+    /// <returns></returns>
+    Task UpdateToContentLanguage(params object[] item);
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="contract"></param>
+    /// <returns></returns>
+    Task ResolveContentAllLanguage(object contract);
+}
diff --git a/src/CSharp/EasyMicroservices.Cores.EntityFrameworkCore/EasyMicroservices.Cores.EntityFrameworkCore.csproj b/src/CSharp/EasyMicroservices.Cores.EntityFrameworkCore/EasyMicroservices.Cores.EntityFrameworkCore.csproj
index 12f9da2..9665918 100644
--- a/src/CSharp/EasyMicroservices.Cores.EntityFrameworkCore/EasyMicroservices.Cores.EntityFrameworkCore.csproj
+++ b/src/CSharp/EasyMicroservices.Cores.EntityFrameworkCore/EasyMicroservices.Cores.EntityFrameworkCore.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Authors>EasyMicroservices</Authors>
-    <Version>0.0.0.64</Version>
+    <Version>0.0.0.65</Version>
     <Description>ef core of database.</Description>
     <Copyright>EasyMicroservices@gmail.com</Copyright>
     <PackageTags>core,cores,base,database,ef,efcore</PackageTags>
diff --git a/src/CSharp/EasyMicroservices.Cores.Relational.EntityFrameworkCore/EasyMicroservices.Cores.Relational.EntityFrameworkCore.csproj b/src/CSharp/EasyMicroservices.Cores.Relational.EntityFrameworkCore/EasyMicroservices.Cores.Relational.EntityFrameworkCore.csproj
index 0363db4..254aefc 100644
--- a/src/CSharp/EasyMicroservices.Cores.Relational.EntityFrameworkCore/EasyMicroservices.Cores.Relational.EntityFrameworkCore.csproj
+++ b/src/CSharp/EasyMicroservices.Cores.Relational.EntityFrameworkCore/EasyMicroservices.Cores.Relational.EntityFrameworkCore.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Authors>EasyMicroservices</Authors>
-    <Version>0.0.0.64</Version>
+    <Version>0.0.0.65</Version>
     <Description>ef core of Relational database.</Description>
     <Copyright>EasyMicroservices@gmail.com</Copyright>
     <PackageTags>core,cores,base,database,ef,efcore,Relational</PackageTags>
diff --git a/src/CSharp/EasyMicroservices.Cores.Tests/DatabaseLogics/LongIdMappedDatabaseLogicBaseTest.cs b/src/CSharp/EasyMicroservices.Cores.Tests/DatabaseLogics/LongIdMappedDatabaseLogicBaseTest.cs
index 1a8f723..bd95403 100644
--- a/src/CSharp/EasyMicroservices.Cores.Tests/DatabaseLogics/LongIdMappedDatabaseLogicBaseTest.cs
+++ b/src/CSharp/EasyMicroservices.Cores.Tests/DatabaseLogics/LongIdMappedDatabaseLogicBaseTest.cs
@@ -113,7 +113,7 @@ public async Task<UserEntity> AddAsync(string userName)
             var user = await logic.Add(addUser);
             Assert.True(user.IsSuccess);
             Assert.True(user.Result > 0);
-            var foundUser = await logic.GetById(new GetIdRequestContract<long>()
+            var foundUser = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = user.Result
             });
@@ -253,7 +253,7 @@ public async Task UpdateAsync(string userName, string toUserName)
             Assert.Equal(updateResult.Result.CreationDateTime, added.CreationDateTime);
             Assert.True(updateResult.Result.CreationDateTime > DateTime.Now.AddMinutes(-5));
             Assert.True(updateResult.Result.ModificationDateTime > DateTime.Now.AddMinutes(-5));
-            var found = await logic.GetById(new GetIdRequestContract<long>()
+            var found = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = added.Id
             });
@@ -283,7 +283,7 @@ public async Task UpdateChangedValuesOnlyAsync(string userName)
             Assert.Equal(updateResult.Result.CreationDateTime, added.CreationDateTime);
             Assert.True(updateResult.Result.CreationDateTime > DateTime.Now.AddMinutes(-5));
             Assert.True(updateResult.Result.ModificationDateTime > DateTime.Now.AddMinutes(-5));
-            var found = await logic.GetById(new GetIdRequestContract<long>()
+            var found = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = added.Id
             });
@@ -389,14 +389,14 @@ public async Task UniqueIdentityAsync(string userName)
         {
             await using var logic = GetContractLogic();
             var added = await AddAsync(userName);
-            var found = await logic.GetByUniqueIdentity(new GetUniqueIdentityRequestContract()
+            var found = await logic.GetByUniqueIdentity(new UniqueIdentityRequestContract()
             {
                 UniqueIdentity = added.UniqueIdentity
             });
             Assert.Equal(found.Result.UserName, userName);
             CheckUniqueIdentity(found.Result.UniqueIdentity);
 
-            var foundAll = await logic.GetAllByUniqueIdentity(new GetUniqueIdentityRequestContract()
+            var foundAll = await logic.GetAllByUniqueIdentity(new UniqueIdentityRequestContract()
             {
                 UniqueIdentity = DefaultUniqueIdentityManager.CutUniqueIdentityFromEnd(added.UniqueIdentity, 2)
             });
@@ -407,7 +407,7 @@ public async Task UniqueIdentityAsync(string userName)
                 var addedProfile = await AddProfileAsync(added.Id, $"Ali{i}");
             }
             await using var profileLogic = GetProfileContractLogic();
-            var foundAllProfiles = await profileLogic.GetAllByUniqueIdentity(new GetUniqueIdentityRequestContract()
+            var foundAllProfiles = await profileLogic.GetAllByUniqueIdentity(new UniqueIdentityRequestContract()
             {
                 UniqueIdentity = added.UniqueIdentity
             });
@@ -415,7 +415,7 @@ public async Task UniqueIdentityAsync(string userName)
             Assert.Contains(foundAllProfiles.Result, x => x.FirstName.StartsWith("Ali"));
             Assert.Equal(foundAllProfiles.Result.Count, 10);
 
-            var onlyUniqueIdentity = await profileLogic.GetByUniqueIdentity(new GetUniqueIdentityRequestContract()
+            var onlyUniqueIdentity = await profileLogic.GetByUniqueIdentity(new UniqueIdentityRequestContract()
             {
                 UniqueIdentity = added.UniqueIdentity
             }, default, q => q.Where(x => x.FirstName == "Ali5"));
@@ -432,7 +432,7 @@ public async Task HardDeleteAsync(string userName)
         {
             await using var logic = GetContractLogic();
             var added = await AddAsync(userName);
-            var found = await logic.GetById(new GetIdRequestContract<long>()
+            var found = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = added.Id
             });
@@ -442,7 +442,7 @@ public async Task HardDeleteAsync(string userName)
                 Id = found.Result.Id
             });
             Assert.True(deleted);
-            found = await logic.GetById(new GetIdRequestContract<long>()
+            found = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = added.Id
             });
@@ -458,7 +458,7 @@ public async Task HardDeleteBulkAsync(string name, string[] userNames)
             foreach (var item in userNames)
             {
                 UserEntity added = await AddAsync(item);
-                var found = await logic.GetById(new GetIdRequestContract<long>()
+                var found = await logic.GetById(new IdRequestContract<long>()
                 {
                     Id = added.Id
                 });
@@ -472,7 +472,7 @@ public async Task HardDeleteBulkAsync(string name, string[] userNames)
             Assert.True(deleted);
             foreach (var item in ids)
             {
-                var found = await logic.GetById(new GetIdRequestContract<long>()
+                var found = await logic.GetById(new IdRequestContract<long>()
                 {
                     Id = item
                 });
@@ -487,7 +487,7 @@ public async Task SoftDeleteAsync(string userName)
         {
             await using var logic = GetContractLogic();
             var added = await AddAsync(userName);
-            var found = await logic.GetById(new GetIdRequestContract<long>()
+            var found = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = added.Id
             });
@@ -498,7 +498,7 @@ public async Task SoftDeleteAsync(string userName)
                 IsDelete = true
             });
             Assert.True(deleted);
-            found = await logic.GetById(new GetIdRequestContract<long>()
+            found = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = added.Id
             });
@@ -560,7 +560,7 @@ public async Task SoftDeleteBulkByIdsAsync(string name, string[] userNames)
             foreach (var userName in userNames)
             {
                 var added = await AddAsync(userName);
-                var found = await logic.GetById(new GetIdRequestContract<long>()
+                var found = await logic.GetById(new IdRequestContract<long>()
                 {
                     Id = added.Id
                 });
@@ -576,7 +576,7 @@ public async Task SoftDeleteBulkByIdsAsync(string name, string[] userNames)
             Assert.True(deleted);
             foreach (var item in ids)
             {
-                var found = await logic.GetById(new GetIdRequestContract<long>()
+                var found = await logic.GetById(new IdRequestContract<long>()
                 {
                     Id = item
                 });
@@ -598,7 +598,7 @@ public async Task SelfChildTestAsync(string parentName, string[] chilren)
             var user = await logic.Add(addUser);
             Assert.True(user.IsSuccess);
             Assert.True(user.Result > 0);
-            var foundUser = await logic.GetById(new GetIdRequestContract<long>()
+            var foundUser = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = user.Result
             });
@@ -647,7 +647,7 @@ public async Task ChildTestAsync(string parentName, string[] chilren)
             var user = await logic.Add(addUser);
             Assert.True(user.IsSuccess);
             Assert.True(user.Result > 0);
-            var foundUser = await logic.GetById(new GetIdRequestContract<long>()
+            var foundUser = await logic.GetById(new IdRequestContract<long>()
             {
                 Id = user.Result
             });