private static async void UseCase_QueryTypesAsync(DataContext dbContext)
        {
            // nur zur Demonstration ein kleines View, hier brauch man keine Migration
            var result = await dbContext.VW_Test.ToListAsync();
            Console.WriteLine(string.Join("\n", result));
        }

 
dbContext.VW_Test.FromSqlRaw(@"select * from VW_Test").ToList()

public class DataContext : DbContext
    {
        // Für die zu erzeugende Tabelle nach dem Code first Prinzip
        public DbSet<Person> Personen { get; set; }
        public DbSet<Geschlecht> Geschlechter { get; set; }
        public DbSet<Herkunft> Herkunft { get; set; }
        public DbSet<Kontinent> Kontinent { get; set; }
        public DbSet<Hobby> Hobby { get; set; }
        public DbSet<PersonHobby> PersonHobby { get; set; }
        public DbSet<VW_Test> VW_Test { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite(@"Data Source=D:\Daten\EntityFrameworkTutorial.db");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            var personBuilder = Build<Person>(modelBuilder);
            var geschlechtBuilder = Build<Geschlecht>(modelBuilder);
            var herkunftBuilder = Build<Herkunft>(modelBuilder);
            var kontinentBuilder = Build<Kontinent>(modelBuilder);
            var hobbyBuilder = Build<Hobby>(modelBuilder);
            var personhobbyBuilder = Build<PersonHobby>(modelBuilder);

            // Property Bedingungen festlegen
            personBuilder
                .Property(x => x.Geburtsdatum)
                .IsRequired();
            personBuilder
                .Property(x => x.HerkunftId)
                .IsRequired();
            personBuilder
                .Property(x => x.IQ)
                .HasDefaultValue(0)
                .IsRequired();
            herkunftBuilder
                .Property(x => x.Deutschsprachig)
                .HasDefaultValue(false);

            // 1 zu n Beziehungen
            personBuilder
                .HasOne(x => x.Geschlecht)
                .WithMany(x => x.Personen)
                .HasForeignKey(x => x.GeschlechtId);
            personBuilder
                .HasOne(x => x.Herkunft)
                .WithMany(x => x.Personen)
                .HasForeignKey(x => x.HerkunftId);
            herkunftBuilder
                .HasOne(x => x.Kontinent)
                .WithMany(x => x.Herkunft)
                .HasForeignKey(x => x.KontinentId);

            // m zu n Beziehungen
            personhobbyBuilder
                .HasOne(x => x.Person)
                .WithMany(x => x.PersonenHobbys)
                .HasForeignKey(x => x.PersonId);
            personhobbyBuilder
                .HasOne(x => x.Hobby)
                .WithMany(x => x.PersonenHobbys)
                .HasForeignKey(x => x.HobbyId);

            // View
            modelBuilder.Entity<VW_Test>()
                        .HasNoKey()
                        .ToView("VW_Test");

            base.OnModelCreating(modelBuilder);
        }

        private EntityTypeBuilder<T> Build<T>(ModelBuilder mb)
            where T : Entity
        {
            var entity = mb.Entity<T>();
            entity.HasKey(x => x.Id);

            // Shadow Properties anlegen die für Entity nicht sichtbar sind und autom. gefüllt werden
            entity.Property<string>("LatestUser")
                  .HasDefaultValue("Admin");

            return entity;
        }
    }

var result = dbContext.VW_Test.ToList();

public string Vorname { get; set; } = null!;

        public DbSet<VW_Test> VW_Test { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite(@"Data Source=D:\Daten\EntityFrameworkTutorial.db");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<VW_Test>()
                        .HasNoKey()
                        .ToView("VW_Test");

            base.OnModelCreating(modelBuilder);
        }

public class VW_Test
    {
        public string Vorname { get; set; }
        public string Nachname { get; set; }
    }

private static void UseCase_QueryTypes(DataContext dbContext)
        {
            var result = dbContext.Set<VW_Test>().ToList();
        }

public class DataContext : DbContext
    {
        // Für die zu erzeugende Tabelle nach dem Code first Prinzip
        public DbSet<Person> Personen { get; set; }
        public DbSet<Geschlecht> Geschlechter { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite(@"Data Source=D:\Daten\Steven IT\Daten\C# Entity Framework Core\Beispielanwendung Einfach\Beispielanwendung Einfach\Data\EntityFrameworkTutorial.db");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Geschlecht>()
                .HasMany(g => g.Personen)
                .WithOne(p => p.Geschlecht);
        }
    }

public class Person
    {
        public int Id { get; set; }
        public string Vorname { get; set; }
        public string Nachname { get; set; }
        public Geschlecht Geschlecht { get; set; }
    }

public class Geschlecht
    {
        public int Id { get; set; }
        public string Bezeichnung { get; set; }
        public List<Person> Personen { get; set; }
    }

class Program
    {
        static void Main(string[] args)
        {
            using (var db = new DataContext())
            {
                var maennlich = new Geschlecht();
                maennlich.Bezeichnung = "Männlich";
                db.Geschlechter.Add(maennlich);

                var weiblich = new Geschlecht();
                weiblich.Bezeichnung = "Weiblich";
                db.Geschlechter.Add(weiblich);
                db.Personen.Add(person);

                person = new Person();
                person.Vorname = "Steven";
                person.Nachname = "S.";
                person.Geschlecht = maennlich;
                db.Personen.Add(person);

                person = new Person();
                person.Vorname = "Lisa";
                person.Nachname = "S.";
                person.Geschlecht = weiblich;
                db.Personen.Add(person);

                db.SaveChanges();
            }
            using (var db = new DataContext())
            {
                foreach (var person in db.Personen)
                {
                    Console.WriteLine($"{person.Id}. {person.Vorname} {person.Nachname} ({person.Geschlecht.Bezeichnung})");
                }
            }

            Console.ReadKey();
        }
    }

namespace PSWPF
{
    public partial class WPFSplashScreen : Window
    {
        #region Props und Konstruktor
        private Status oStatus;

        public WPFSplashScreen(string sProgramName, string sVersion)
        {
            InitializeComponent();

            labProgramName.Content = sProgramName;
            labVersion.Content = sVersion;

            oStatus = new Status();
            this.DataContext = oStatus;
        }
        #endregion

        #region Hilfsmethoden
        public void SetStatusText(string sText)
        {
            oStatus.sStatus = sText;
        }

        public string GetStatusText()
        {
            return oStatus.sStatus;
        }
        #endregion
    }

    public class Status : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private string _status;
        public string sStatus
        {
            get { return _status; }
            set
            {
                _status = value.Trim();

                OnPropertyChanged("sStatus");
            }
        }

        private void OnPropertyChanged(string sProperty)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(sProperty));
        }
    }
}

...
this.oWPFSplashScreen = new WPFSplashScreen(this.ProgramName, this.Version);
this.oWPFSplashScreen.Show();

this.oWPFSplashScreen.SetStatusText("Login...");
...

WPFWindow oWPFWindow = new WPFWindow();
oWPFWindow .Show();

namespace PSBase.FE.WPF
{
    public partial class PSWPF : Window
    {
      ...
    }
}

...
using PSBase.FE.WPF;

namespace Test
{
    public partial class MainWindow : PSWPF
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }
}

namespace PSBase.FE.WPF
{
    public partial class PSWPF : Window
    {
      ...
    }
}

...
using PSBase.FE.WPF;

namespace Test
{
    /// <summary>
    /// Interaktionslogik für MainWindow.xaml
    /// </summary>
    public partial class MainWindow : PSWPF
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }
}

public class Repository
{
        private string sSQLPath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "Team.SQLite");

        public Repository()
        {
            using (SQLiteConnection con = new SQLiteConnection(new SQLitePlatformAndroidN(), sSQLPathSpielstatistik, false))
            {
                con.CreateTable<SAI_Saison>();
                con.CreateTable<SPI_Spieler>();
                con.CreateTable<SAI_SPI_Saison_Spieler>();
            }
        }

        private List<SPI_Spieler> GetAll_SPI_Spieler()
        {
            using (SQLiteConnection con = new SQLiteConnection(new SQLitePlatformAndroidN(), sSQLPath, false))
            {
                return con.Table<SPI_Spieler>().Where(s => s.Aktiv == true).ToList() ?? new List<SPI_Spieler>();
            }
        }

        public List<SAI_Saison> GetAll_SAI_Saison()
        {
            using (SQLiteConnection con = new SQLiteConnection(new SQLitePlatformAndroidN(), sSQLPath, false))
            {
                return con.Table<SAI_Saison>().ToList() ?? new List<SAI_Saison>();
            }
        }

        private SAI_SPI_Saison_Spieler Get_SAI_SPI_Saison_Spieler(int iSaison_ID, int iSpieler_ID)
        {
            using (SQLiteConnection con = new SQLiteConnection(new SQLitePlatformAndroidN(), sSQLPath, false))
            {
                return con.Table<SAI_SPI_Saison_Spieler>().Where(s => s.Saison_ID == iSaison_ID && s.Spieler_ID == iSpieler_ID).ToList().FirstOrDefault() ?? new SAI_SPI_Saison_Spieler();
            }
        }
}

// Zugriff aus der App 1
private string sSQLPath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "App.SQLite");
// Pfad: "/data/user/0/com.App/files/App.SQLite"

using (SQLiteConnection con = new SQLiteConnection(new SQLitePlatformAndroidN(), sSQLPath, false))
{
       con.CreateTable<TAB_Tabelle>();
       // Insert...
}

// Zugriff aus der App 2
private string sSQLPath = "/data/user/0/com.App/files/App.SQLite"

if (File.Exists(sSQLPath))
{
   using (SQLiteConnection con = new SQLiteConnection(new SQLitePlatformAndroidN(), sSQLPath, false))
   {
          con.CreateTable<TAB_Tabelle>();
          // Get...
   }
}