public class Machine(){

 public bool RowTopWin{...} // gibt zurück ob 1. Zeile Gewinn
 public bool RowMiddleWin{...}
 public bool ColumnLeftWin{...}

}

            // Modelle von Datenbank beziehen:
            var orders = _SqlRepo.GetOrders();
            orders.Wait();


            // Modelle die in ViewModel Liste bereits referenziert sind:
            var ordersToReplace = _Orders.Where(
                c => 
                orders.Result.FirstOrDefault(old => old.OrderID == c.OrderID) != null)
                .ToList();
            
            
            // vorhandene ViewModels ersetzen:
            ordersToReplace.Select(
                c => 
                c = new OrderViewModel(
                    orders.Result.Where(c => c.OrderID == c.OrderID).First()
                    )
                );

            // ViewModels, für die es kein Modell gibt ==> löschen
            var ordersToDelete = _Orders.Where(
                vm => 
                orders.Result.FirstOrDefault(model => model.OrderID == vm.OrderID) == null)
                .ToList();

            foreach(var orderToDelte in ordersToDelete)
                _Orders.Remove(orderToDelte);


            // Models, für die es kein ViewModel gibt ==> hinzufügen:
            var ordersToAdd = orders.Result.Where(
                c => _Orders.FirstOrDefault(vm => vm.OrderID == c.OrderID) == null)
                .ToList();

            // ViewModel für Modell erstellen & hinzufügen:
            foreach (var order in ordersToAdd)
                _Orders.Add(new OrderViewModel(order));

Form3 form3 = new Form3("C:\mein_bild.jpg");

            // "Order"-Objekte aus der Datenbank
            var orders = await _SqlRepo.GetOrders();
            // Liste mit ViewModels (werden in Window abgerufen)
            _Orders.Clear();
            
            foreach(var order in orders)
            {
                var vm = new OrderViewModel(order);

                _Orders.Add(vm);
            }

    public interface IWindowManager
    {
        void ShowOrderWindow(OrderViewModel order);
...
    }

await System.Threading.Tasks.Task.Run(() => PrepareMailsAsync(emailMessages));

        public OrderDetailsViewModel(Order order, IDBRepo dbRepo)

public OrderDetailsViewModel(Order order, IDBRepo dbRepo, MainWindowViewModel parent)

    public class Article
    {
        public int ArticleID { get; set; }
        public string Title { get; set; }
        public Order Order { get; set; }
...

    public class Customer
    {
        public int CustomerID { get; set; }
        public string Firstname { get; set; }
        public string Lastname { get; set; }
        public List<Order> Orders { get; set; } = new List<Order>();
...
    public class Order
    {
        public int OrderID { get; set; }
        public string Title { get; set; }
        public Customer Customer { get; set; }
        public List<Article> Articles { get; set; } = new List<Article>();
...

    public class LocalDb : IAvService
    {
        private LiteDB.LiteDatabase _db;


        private ILiteCollection<Order> GetOrderCollection
        {
            get { return _db.GetCollection<Order>("orders"); }
        }
        private ILiteCollection<Customer> GetCustomerCollection
        {
            get { return _db.GetCollection<Customer>("customers"); }
        }

        private ILiteCollection<Article> GetArticleCollection
        {
            get { return _db.GetCollection<Article>("articles"); }
        }


        public LocalDb(string dbFile)
        {
            _db = new LiteDatabase(dbFile);
            BsonMapper.Global.Entity<Order>()
                .DbRef(x => x.Customer, "customers");
            BsonMapper.Global.Entity<Order>()
                .DbRef(x => x.Articles, "articles");
            BsonMapper.Global.Entity<Customer>()
                .DbRef(x => x.Orders, "orders");
            BsonMapper.Global.Entity<Article>()
                .DbRef(x => x.Order, "orders");
        }

        public Task<Customer> AddCustomer(Customer customer)
        {
            return Task<Customer>.Run(() =>
            {
                var col = GetCustomerCollection;
                var id  = col.Insert(customer);
                return col.FindById(id);
            });
        }
...

            IAvService av = new LocalDb("test.db");

            Order order = new Order
            {
                Title = "Test"
            };


            Article article1 = new Article
            {
                Title = "Arbeitszeit",
                Price = 60,
                Tax = 0.16
            };

            var dbArticle = av.AddArticle(article1).GetAwaiter().GetResult();

            Console.WriteLine($"Artikel ID: {dbArticle.ArticleID}");

            order.Articles.Add(dbArticle);

            order.Customer = av.AddCustomer(new Customer()
            {
                Firstname = "Max",
                Lastname = "Mustermann"
            }).GetAwaiter().GetResult();

            av.AddOrder(order);

Order order = new Order{
   Customer = new Customer{...}
}