DataProvider mit unterschiedlichen Context, Best Practice

  • WPF

Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von florian03.

    DataProvider mit unterschiedlichen Context, Best Practice

    Hi,
    ich stehe gerade etwas auf dem Schlauch.
    Ich möchte dem User anbieten ausuchen zu können, zu welcher DB er connecten möchte. (SQLite, SQLServer, MySQL)
    Dazu habe ich für jede Möglichkeit einen Context erstellt, der von einem Basis Context ableitet und dann entsprechend den optionsBuilder configuriert.
    Soweit ist das denke ich OK (oder gibts eine bessere Möglichkeit?)

    Nun habe ich aber das Problem, das ich im DataProvider ja explicit sagen muss, mit welchem Context der Provider arbeiten soll.
    Da hänge ich gerade.

    Hier etwas Code:

    Interface Context
    ​

    C#-Quellcode

    1. ​
    2. public interface IDbContext : IDisposable
    3. {
    4. DbSet<Absence> Absences { get;}
    5. DbSet<Company> Companies { get;}
    6. DbSet<LoginData> Logins { get;}
    7. DbSet<Person> People { get;}
    8. DbSet<TimeEntry> TimeEntries { get;}
    9. EntityEntry<TEntity> Entry<TEntity>(TEntity entity) where TEntity : class;
    10. int SaveChanges();
    11. Task<int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken));
    12. }



    Context Base
    ​

    C#-Quellcode

    1. ​
    2. public abstract class DbContextBase : DbContext, IDbContext
    3. {
    5. protected readonly string _connectionString = null;
    7. public DbContextBase(string connectionString)
    8. {
    9. _connectionString = connectionString;
    10. }
    12. #region DbSets
    13. public virtual DbSet<Absence> Absences { get; set; }
    15. public virtual DbSet<Company> Companies { get; set; }
    17. public virtual DbSet<LoginData> Logins { get; set; }
    19. public virtual DbSet<Person> People { get; set; }
    21. public virtual DbSet<TimeEntry> TimeEntries { get; set; }
    22. #endregion
    23. }



    Interface Provider
    ​

    C#-Quellcode

    1. ​
    3. public interface IDataProvider<T> : IDisposable
    4. {
    6. #region Get Methods
    8. Task<T> GetByIdAsync(int id);
    9. Task<IList<T>> GetListAsync();
    10. Task<IList<T>> GetListAsync(DataRequest<T> request);
    11. Task<IList<T>> GetListAsync(int skip, int take, DataRequest<T> request);
    12. Task<IList<T>> GetKeysAsync();
    13. Task<IList<T>> GetKeysAsync(DataRequest<T> request);
    14. Task<IList<T>> GetKeysAsync(int skip, int take, DataRequest<T> request);
    15. Task<int> GetListCountAsync();
    16. Task<int> GetListCountAsync(DataRequest<T> request);
    18. #endregion
    20. #region Update Methods
    22. Task<int> UpdateAsync(T item);
    23. Task<int> DeleteAsync(params T[] items);
    25. #endregion


    Basis Provider
    ​

    C#-Quellcode

    1. ​
    2. public abstract class DataProviderBase : IDisposable
    3. {
    4. private bool _disposeContext;
    5. internal DbContextBase Context { get; set; }
    7. public DataProviderBase()
    8. {
    9. CreateContext(/*hier neuen Context erstelles, also entweder SQLContext, oder SQLite Context usw.*/);
    10. _disposeContext = true;
    11. }
    13. internal DataProviderBase(DbContextBase context)
    14. {
    15. CreateContext(context);
    16. _disposeContext = false;
    17. }
    19. private void CreateContext(DbContextBase context)
    20. {
    21. Context = context;
    22. Context.ChangeTracker.LazyLoadingEnabled = false;
    23. Context.ChangeTracker.AutoDetectChangesEnabled = false;
    24. Context.Database.EnsureCreated();
    25. }
    27. public void Dispose()
    28. {
    29. if (_disposeContext) Context.Dispose();
    30. }
    33. }


    Beispiel People Provider
    ​

    C#-Quellcode

    1. ​
    2. public class PeopleProvider : DataProviderBase, IDataProvider<Person>
    3. {
    4. private readonly DbContextBase _context = null;
    5. public PeopleProvider(DbContextBase dbContext) : base(dbContext)
    6. {
    7. _context = dbContext;
    8. }
    10. public Task<int> DeleteAsync(params Person[] items)
    11. {
    12. throw new NotImplementedException();
    13. }
    15. public async Task<Person> GetByIdAsync(int id)
    16. {
    17. return await _context.People.Where(p => p.Id == id).FirstOrDefaultAsync();
    18. }
    20. public Task<IList<Person>> GetKeysAsync()
    21. {
    22. throw new NotImplementedException();
    23. }
    25. public Task<IList<Person>> GetKeysAsync(DataRequest<Person> request)
    26. {
    27. throw new NotImplementedException();
    28. }
    30. public Task<IList<Person>> GetKeysAsync(int skip, int take, DataRequest<Person> request)
    31. {
    32. throw new NotImplementedException();
    33. }
    35. public Task<IList<Person>> GetListAsync()
    36. {
    37. throw new NotImplementedException();
    38. }
    40. public Task<IList<Person>> GetListAsync(DataRequest<Person> request)
    41. {
    42. throw new NotImplementedException();
    43. }
    45. public Task<IList<Person>> GetListAsync(int skip, int take, DataRequest<Person> request)
    46. {
    47. throw new NotImplementedException();
    48. }
    50. public Task<int> GetListCountAsync()
    51. {
    52. throw new NotImplementedException();
    53. }
    55. public Task<int> GetListCountAsync(DataRequest<Person> request)
    56. {
    57. throw new NotImplementedException();
    58. }
    60. public Task<int> UpdateAsync(Person item)
    61. {
    62. throw new NotImplementedException();
    63. }
    64. }


    Wie bekomme ich es nun hin, im DataProviderBase nicht explicit einen bestimmten Context einzubauen?
    Die Auswahl, welche DB benutzt werden soll, geschieht ja im View Projekt, dort liegen auch die AppSettings da manche Settings auf View interne Sachen zugreifen müssen.
    Ich habe also im Provider Projekt keinen Zugriff auf die AppSettings

    Danke Euch für nen Denkanstoß.
    Grüße Michael
    "Hier könnte Ihre Werbung stehen..."

    Hi,

    ich beschäftige mich auch gerade mit EntityFramework.
    Ich glaube, du musst es dir gar nicht so kompliziert machen.

    Als Beispiel nehme ich hier mal die ​OnConfiguring Methode aus @Nofear23ms WPFNotes Projekt.
    Dort unterscheidet er ja auch zwischen einer InMemory Datenbank für die UnitTests und der ganz normalen.

    Hier mal der Code:

    C#-Quellcode

    1. ​
    2. protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    3. {
    4. connString = Instance.CurrentConnectionString;
    5. if (!optionsBuilder.IsConfigured)
    6. {
    7. Debug.WriteLine($"Configured connectionstring: {connString}");
    9. if (connString.Contains("InMemory"))
    10. {
    11. optionsBuilder.UseInMemoryDatabase(connString);
    12. }
    13. else
    14. {
    15. optionsBuilder.UseSqlite(connString);
    16. }
    17. }
    18. }


    Du könntest doch einfach in deinem InstanceHolder oder in der Context Klasse selbst ein Enum mit der verwendeten Datenbank speichern.
    Dann gehst du einfach mit Select Case in der Methode die einzelnen verfügbaren Datenbanken durch und erstellst je nach Fall die entsprechende Datenbankverbindung.

    So würde ich das lösen.

    Viele Grüße
    Florian
    ----

    WebApps mit C#: Blazor

Facebook
Telefonspende