Sind diese Addxxx-Methoden wirklich asynchron? Warum verwendest du dann nicht await (mit Task.ConfigureAwait(false))?

Nein, ich wollte es im Interface aber als Task definieren, dass ich später evtl. mal eine asynchrone REST-, RPC-Schnittstelle oder ähnliches dazwischen klemmen könnte.
Der Aufruf soll später auch mit await stattfinden, das war nur ein Testaufruf in einer Konsole.

Im Endeffekt ist das weder ein Service, noch eine Db - sondern im Prinzip nichts anderes als (eine sehr einfache Variante) des Repository Pattern.

Oh man, dieses Pattern vorher zu kennen wäre nützlich gewesen... 😁
Wen es interessiert, hier habe ich auch ein gutes Beispiel gefunden: Implementieren von Repository-und Arbeitseinheiten Mustern in einer ASP.NET MVC-Anwendung (9 von 10)

Vielleicht baue ich direkt auf deinen Code auf 😁

Danke euch beiden!

PS: Gibt es schon eine Funktion in C# welche nach einer bestimmten Zeichenanzahl einen bestimmten Wert einfügt?

Ja: String.Insert

Bzgl. Klasse: Die Methode verwendest du ja bereits in irgendeiner Klasse. Wenn du es an mehreren Stellen brauchst, solltest du es natürlich auslagern. Die Frage ist dann ehr statisch oder nicht. Das kommt auf den Input, Funktionen,... an.

Hi,

vielleicht kennt ja der ein oder andere LiteDB.
Da ein SQL-Server für dieses Projekt zu aufwendig wäre, würde ich gerne eine lokale Datenbank einsetzen. Vielleicht kennt ja jemand auch eine bessere Alternative.

Ich nehme als Beispiel wieder eine kleine Auftragsverwaltung - Auftrag - Kunde - Artikel.

    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>();
...

Für die Datenabfrage habe ich mir einen kleine Abstraktionsschicht geschrieben:

    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);
            });
        }
...

Erstelle ich einen neuen Auftrag mit Artikeln und Kunde löse ich das bisher so.
Da die Objekte (Artikel, Customer....) noch keine ID haben, muss ich sie erst separat in die Datenbank geben.

            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);

Hier wollte ich fragen ob das soweit alles passt, da sich das ja durch mein komplettes Programm ziehen wird.
Was mich noch etwas stört ist bzw. was etwas unschön aussieht, dass ich alles erst Adden muss,
also es nicht direkt hinzufügen kann, wie bei EF: (Oder geht das doch irgendwie damit?)

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

Ein Kollege von mir hat ein Tool in Delphi geschrieben und das ist gerade einmal 4 MB groß. Als Vergleich habe ich nur mal die GUI nachgebaut und komme allein da schon auf 120 MB? Und ich habe auf meinem System kein Delphi installiert, daher muss da ja auch alles mitkommen. Kann mir das bitte jemand erklären?

Absolute .NET Grundlagen, kannst ja auch Programme in Assembler schreiben, dann sind sie noch kleiner.

Sieh dir mal lieber das https://html-agility-pack.net/ an, bevor du mit sowas rumwerkelst. Vorallem wenn es größer werden soll.

Wenn es an sowas schon scheitert, geh ich mal ganz stark davon aus, dass du gar nicht genau weißt was du da überhaupt machst.

Du hast eine Server Applikation und eine Client Applikation? Ist die Client Applikation auch ein WPF Projekt? Wie kommunizieren die? Was willst du runterladen?

Da fehlt ein else im Code, das hätte man durch die Codeformatierung schon gesehen 😉

=> Und diese Variablennamen,... da muss ich aber los...

Das kommt auf deine Ansprüche an, ob nur ein Benutzer,...

Bei sowas einfachen würde ich ein Listen Objekt serialisieren.

Du kannst doch theoretisch auch mit dem CLI das Projekt "richtig" erstellen:

dotnet new webapi

Dann kannst du ja auch Notepad als Editor verwenden 😁

Ich weiß jetzt nicht ob ich zu kompiliziert oder falsch denke, aber ich kann mir doch so alle aufzählen (ohne Schleife von Abts Link). Dann füge ich alle Matches in eine Liste ein mit einer ID, und schau ob es sie schon gibt, das sollte ja dann noch das einfachste sein.

            string[] ms = new string[] { "m1", "m2", "m3"};
            string[] ws = new string[] { "w1", "w2", "w3" };

            var result = from m in ms
            from w in ws
            select new { m = m, w= w };

            foreach(var r in result)
            {

                var gegner = result.Where(c => c.m != r.m && c.w != r.w);

                foreach(var tmpGegner in gegner)
                {
                    Console.WriteLine($"{r} vs. {tmpGegner}");
                }

            }

{ m = m1, w = w1 } vs. { m = m2, w = w2 }
{ m = m1, w = w1 } vs. { m = m2, w = w3 }
{ m = m1, w = w1 } vs. { m = m3, w = w2 }
{ m = m1, w = w1 } vs. { m = m3, w = w3 }
{ m = m1, w = w2 } vs. { m = m2, w = w1 }
{ m = m1, w = w2 } vs. { m = m2, w = w3 }
{ m = m1, w = w2 } vs. { m = m3, w = w1 }
...
{ m = m3, w = w1 } vs. { m = m2, w = w3 }
{ m = m3, w = w2 } vs. { m = m1, w = w1 }
{ m = m3, w = w2 } vs. { m = m1, w = w3 }
{ m = m3, w = w2 } vs. { m = m2, w = w1 }
{ m = m3, w = w2 } vs. { m = m2, w = w3 }
{ m = m3, w = w3 } vs. { m = m1, w = w1 }
{ m = m3, w = w3 } vs. { m = m1, w = w2 }
{ m = m3, w = w3 } vs. { m = m2, w = w1 }
{ m = m3, w = w3 } vs. { m = m2, w = w2 }

Naja, mal ganz ehrlich

"immer nur verschieben, und das jetzt als Code"

Wenn ich wüsste wie man das als code umsetzt hätte ich nicht gefragt.

Suche von Algorithmus für das Erstellen eines Spielplans, du sagtest du willst einen Algorithmus und damit geht es.

Ausserdem klappt das nicht so(siehe bild).

Was du mit dem Bild sagen willst verstehe ich immer noch nicht.

Einfachstes Beispiel:

            int mCount = 3;
            int wCount = 3;
            for(int m=1; m<=mCount; m++)
            {
                for(int w=1; w<=wCount; w++)
                {
                    Console.WriteLine($"Team: m{m} vs. w{w}");
                }

            }

Team: m1 vs. w1
Team: m1 vs. w2
Team: m1 vs. w3
Team: m2 vs. w1
Team: m2 vs. w2
Team: m2 vs. w3
Team: m3 vs. w1
Team: m3 vs. w2
Team: m3 vs. w3

Für die Partien musst du dann einfach prüfen das niemand zwei mal vorkommt.
Das ist genau das von oben.

Beispiel:

m1 m2 w1 w2
1 0 1 0
1 0 0 1
0 1 1 0
0 1 0 1

==> m1 & w1 vs. m2 & w2
==> (m1 & w2 vs. m2 & w1

immer nur verschieben, und das jetzt als Code

Es gibt immer m^2 Möglichkeiten, wobei m die Anzahl der Männer z.b. ist.

m1 m2 w1 w2
1 0 1 0
1 0 0 1
0 1 1 0
0 1 0 1

m1 m2 m3 w1 w2 w3
1 0 0 1 0 0
1 0 0 0 1 0
1 0 0 0 0 1
0 1 0 1 0 0
0 1 0 0 1 0
0 1 0 0 0 1
...

Wenn ich das jetzt richtig verstanden habe.
Ist dann einfach abgrasen der Optionen, Partien speichern und damit auswählen.

Ich hoffe es ist okay wenn ich hier kurz eine Frage genau zu diesem poste:

Angenommen ich habe Models (z.B. Order) und will davon Ableitungen haben (ProductOrder, ServiceOrder, etc.).

Sollte ich, wenn ich mit sowas arbeite direkt auf NoSQL Datenbanken setzen? Nachdem was ich gesehen habe würde es zwar mit EntityFramework & einem SQL Server gehen, aber sqlite und sowas nicht mehr?

Viele Grüße

Achso sorry hatte seine Frage nicht verstanden

Man könnte es ja auch z.B. so machen:

    public static class Form1ErweiterungMethod
    {
        public static void SetText(this Form1 form, string title)
            => form.Text = title;
    }

Würde da dagegen was sprechen, bzw. was wäre daran der Nachteil gegenüber einer Ableitung? @Abt, Th69,...

Erstell dir ein ViewModel, dann kannst du die Koordinaten binden.

Siehe [Artikel] MVVM und DataBinding

Super, vielen Dank euch Beiden!

Okay, das macht Sinn, danke.

Angenommen ich hätte einen Array mit Dateinamen von Bildern und ich will die geladenen Image Objekte z.B. mit GetAllImages() zurückgeben, bei sowas würde ich es dann einsetzen?

...
public IEnumerable GetAllImages()
{
...
   yield return Image.FromFile(image[i]);;
}

Hi,

mal eine ganz grundlegende Frage:

Angenommen ich hätte eine Klasse die auf eine Datenbank zugreift:

// Pseudocode:
public class Datenbank
{
     public IEnumerable GetArticles()
     {
        foreach...
          yield return article;
      }
      // oder
      public List<Article> GetArticles()
      {
            return articles;
       }
}

Gibt es da irgendwelche Performancevorteile, bzw. wann sollte ich auf IEnumerable zurückgreifen anstatt z.B. der ganzen Liste? Wenn ich sehr speicherintensive Objekte habe?

da ich mit .NET Framework arbeite (.NET CORE gibts nicht mit Views oder?)
kann ich nur C# 7.3.

Ich weiss nicht ob mir das Buch da weiterhilft.

Ich gehe mal davon aus dass es zwischen Version 7.3 und 8 keine solchen fundamentalen Änderungen gibt, dass du damit überhaupt nicht mehr klar kommst 😁 Du kannst das Buch theoretisch auch mit einer uralt Version durch machen, alle Neuerungen der Versionen sind angeführt.

Es ist nirgendwo aufgeführt dass das Buch ausschließlich mit .NET Core arbeitet? Ich denke für dich würde das eh keinen merkbaren Unterschied bei der Entwicklung machen.

Wenn ich lernen will wie MVVM funktioniert, muss ich etwas haben woran/womit ich es lernen kann.
Bücher gibts keine gescheiten, YouTube?, Foren evtl. und! funktionierender Code den ich analysieren kann..

Ich arbeite derzeit das Buch C# 8 mit Visual Studio 2019: Das umfassende Handbuch von Andreas Kühnel durch, da wird auch MVVM behandelt. Ich kann das Buch wirklich auch für die Festigung grundlegender Kenntnisse empfehlen. Vorallem noch mal die ausführliche Einarbeitung in delegates und Events dürfte da einiges erklären.

Ist eigentlich ganz einfach. Wenn man irgendwann in der Lage ist, andere Leute oder Firmen in einem bestimmten Bereich zu beraten, dann merkt man das selbst. Und dann kann man sich selbständig machen (Freiberufler) oder eine Firma gründen.

Ja klar, aber selbst wenn du der Beste bist werden ja nicht automatisch Firmen auf dich zukommen, ich meine ehr wie man dann da die Kontakte knüpft / Anschluss findet. Ich schätze mal wenn du ein paar größere Projekte mal mitgemacht hast geht der Rest von alleine oder?

Mega cool, danke für den Einblick 🙂
Kannst du da ein paar Konferenzen empfehlen, die man einfach so besuchen kann? Also am besten für .NET, Softwareentwicklung,...

Danke für die Antwort!

Wie hast du dann angefangen? Also ich schätze mal . erst normal in dem Bereich gearbeitet/Erfahrung gesammelt, usw.? Aber wie macht man dann den Schritt in die Selbstständigkeit? Hattest du die ersten Aufträge durch Kontakte, ehemalige Arbeitgeber,... oder wie bist da rein gekommen?

Hey,

nur mal so aus Neugierde da es ja auch Firmen gibt die sich auf Beratung für die Softwareentwicklung in C# spezialisiert haben, etc.

Wie steigt man in diesem Bereich ein? Also als Selbständiger. Gibt es da von Microsoft Zertifizierungen oder kommt es da ehr auf die Erfahrung/vergangene Projekte an? Wenn ja, wie kommt man da rein bzw. wie fängt man an?

Viele Grüße

Ich muss nochmal kurz nerven,
jetzt wenn man ein bisschen was gemacht hat und auch mal selbst einen Command angelegt hat muss man schon sagen es ist irgendwie um einiges komfortabler als WinForms 😁

Per DI injecte ich jetzt den Datenservice in das OrdersViewModel, darin habe ich mir zwei Commands angelegt:

    public class OrdersViewModel : BaseViewModel
    {
        private List<OrderViewModel> _Orders = new List<OrderViewModel>();
        private AvService _avService;
        public ICommand ShowDetailsCommand { get; set; }
        public ICommand UpdateOrderCommand { get; set; }

        public OrderViewModel SelectedOrder { get; set; }

...


        private void showDetails(OrderViewModel order)
        {
            // simple window
            Window frmDetails = new Window();
            frmDetails.Content = new OrderUserControl(this, order);
            frmDetails.Show();
        }

        private Order UpdateOrder(Order order, OrderViewModel orderView)
        {
            order.Title = orderView.Title;
            // ... 
            return order;
        }

        public OrdersViewModel(AvService avService)
        {
            this._avService = avService;

            // ShowDetails Command, TODO Can execute
            ShowDetailsCommand = new RelayCommand( p =>
                   showDetails(this.SelectedOrder)
                ) ;

            UpdateOrderCommand = new RelayCommand(p => 
                avService.UpdateOrder( this.UpdateOrder(
                    avService.GetOrders()
                        .Where( x=> x.OrderId == (p as OrderViewModel).Id)
                        .First(), (p as OrderViewModel))
                    )
            );
        }

Der ShowDetailsCommand ist an einen Button im MainWindow gebunden, der öffnet dann mein Usercontrol testweise in einem temporären Fenster.

Nun zum UpdateOrderCommand, der soll das geänderte OrderViewModel in der Datenbank speichern, dazu mappe ich die Änderungen des ViewModels auf die des Order-Models und speichere sie in der Datenbank.

⚠ Würde man das so machen dass dem UserControl die ViewModel Instanz übergeben wird oder würde man sich da ehr an ein Event dranhängen?

User-Control:

    public partial class OrderUserControl : UserControl
    {
        private OrdersViewModel _orders;
        private OrderViewModel _order;

        public OrderUserControl(OrdersViewModel orders, OrderViewModel order)
        {
            InitializeComponent();
            this._orders = orders;
            this._order = order;

            this.DataContext = new
            {
                order = _order,
                orders = _orders
            };

            
        }
    }

        <Label Content="Title:"/>
        <TextBox Text="{Binding order.Title}"/>

        <Button Content="Save" Command="{Binding orders.UpdateOrderCommand}" CommandParameter="{Binding order}" />

Das ganze funktioniert ohne Probleme, die Frage ist aber ob das der way to go ist sollte das Projekt mal größer werden?

Danke euch schonmal für eure Geduld 8)

Super danke euch!

Ich denke ich nutze dann ehr die List bzw. IReadOnlyCollection Methode, da ich die Daten ja nur über den Service beziehe.

Danke euch!

Der Artikel erklärts ja recht schön nur verstehe ich dann den Einbezug von Models nicht.

Meinst du z.B. ich injecte den avService in das OrdersViewModel und manage da drüber alles?

D.h. einmalig die Liste so initalisieren,
und dann über einen Command z.B. avService.CreateOrder() und davon ein ViewModel in die Collection geben? ==> Also dass das OrdersViewModel nochmal eine Schicht zw. Datenbank Service und GUI ist?

Ja, ich habs gerade auch versucht und es ging natürlich nicht =), sorry das hat mich alles ein bisschen verwirrt.

        private AvService _avService;
        private OrdersViewModel _orders = new OrdersViewModel();

        public MainWindow()
        {
            InitializeComponent();
            this._avService = new AvService("test.db");


            this.DataContext = this._orders;

            refreshOrders();
        }

        private void refreshOrders()
        {

            var viewModels = this._avService.GetOrders().Select(model => new OrderViewModel(model) );
            this._orders.Orders = new ObservableCollection<OrderViewModel>(viewModels);


        }

Und so verweise ich darauf:

<DataGrid ItemsSource="{Binding Orders}"/>

Mein ganzes Wissen darüber habe ich bisher nur aus diesem Artikel 😄
OrdersViewModel entspricht dem CompanyViewModel.
Ich schätze ich kann die

private ObservableCollection<OrderViewModel> _Orders

auch direkt in der MainForm deklarieren, und die dann in XML ansprechen.

Danke euch, wenn ich noch Fragen habe mache ich einen neuen Thread auf um diesen nicht zu arg voll zu spamen.

Viele Grüße

Danke für deine Antwort,

nur verstehe ich da jetzt nicht ganz den Unterschied:

var viewModels = models.Select(model => new ViewModel() { Data = model.Data });
Items = new ObservableCollection<ViewModel>(viewModels);

Du erstellst doch da auch nur eine neue ObservableCollection mit den ViewModels.

Der Code bei mir macht doch das gleiche oder habe ich einen Denkfehler?!
ordersView.Orders ist ja die ObservableCollection des OrdersViewModel (entspricht Company in deinem Artikel), und der füge ich die ViewModels der Models hinzu.
Sorry bin noch relativ frisch in der Materie und mir fehlt da ein bisschen der Überblick.

foreach (var order in this._avService.GetOrders())
            {
                this._ordersView.Orders.Add(new OrderViewModel(order));
            }

    public class OrdersViewModel : BaseViewModel
    {
        private ObservableCollection<OrderViewModel> _Orders = new ObservableCollection<OrderViewModel>();

        public ObservableCollection<OrderViewModel> Orders
        {
...

Hier hast du offensichtlich denn Sinn einer ObservableCollection nicht verstanden. Die ObservableCollection ermöglicht es, eine veränderbare Liste mit Daten an die View zu binden, damit diese sich bei Datenänderungen automatisch aktualisieren kann.

Das ist genau mein Problem,
wie komme ich von den Models auf eine ObservableCollection mit den ViewModels, sodass ich WPF auch effektiv nutze.

@Abt danke für die Links 👍 vielleicht erklärt sich ja dadurch dann meine Frage

Danke euch!

Außerdem sollte die DB-Klasse (und auch die Logik-Schicht) nichts von ViewModels wissen, sondern du solltest Modelldaten dafür erzeugen und verwenden.
Die UI-Schicht erzeugt dann aus diesen Modelldaten die passenden ViewModel-Daten (generell ist es aber normal, daß die ObservableCollection<T> jedesmal wieder neu erzeugt wird, wenn sich die Daten ändern - evtl. kannst du aber ein Caching einbauen, wenn es performancemäßig relevant ist).

Ich hatte genau die gleiche Fragestellung wie der Threadsteller, da ich derzeit ein kleines Testprojekt in WPF mache:
der avService liefert mir die Models aus einer Datenbank (Order, Customer,...).
Der Konstruktur des OrderViewModels mappt sich die dann vom Model. (könnte man noch auslagern um Abhängigkeiten zu verringern)

Würde man das so machen oder gibt es da noch etwas eleganteres? Wenn ein Objekt bearbeitet wird triggere ich dann z.B. nur den avService.UpdateOrder(...) und refreshe das ganze?

    public partial class MainWindow : Window
    {
        private AvService _avService;
        private OrdersViewModel _ordersView = new OrdersViewModel();

        public MainWindow()
        {
            InitializeComponent();
            this._avService = new AvService("test.db");
            refresh();
        }

        private void refresh()
        {
            this._ordersView.Orders.Clear();
            foreach (var order in this._avService.GetOrders())
            {
                this._ordersView.Orders.Add(new OrderViewModel(order));
            }

            dgOrders.ItemsSource = this._ordersView.Orders;
        }
    }

    public class OrdersViewModel : BaseViewModel
    {
        private ObservableCollection<OrderViewModel> _Orders = new ObservableCollection<OrderViewModel>();

        public ObservableCollection<OrderViewModel> Orders
        {
            get { return _Orders; }
            set
            {
                if (value != _Orders)
                {
                    _Orders = value;
                    OnPropertyChanged(nameof(Orders));
                }
            }
        }
    }

Ich versteh nicht genau was du machen willst,

args.Length gibt dir die Anzahl an Parametern, also die Länge des arrays.
Mit args[0,...] greifst du dann auf die einzelnen Parameter zu.

Siehe hier:
https://docs.microsoft.com/de-de/dotnet/csharp/programming-guide/main-and-command-args/how-to-display-command-line-arguments

Das mit den Fileshares war nur ein Beispiel, da hast du Recht, da ist Onedrive,... besser dafür

Es geht mehr darum überhaupt einen VPN zu haben, wenn man mal in einem fremden WLAN ist, etc.
Und das man darüber gleich auf webbasierte interne Tools zugreifen kann.
Macht das Sinn einen VPN auf Azure zu hosten? ODer gibt es da was besseres?

Hi,

habe nochmal eine Frage zu dem Thema.
Angenommen ihr wollt für eine Firma von null aus eine Infrastruktur aufbauen.
Wie würde man das z.B. mit Azure machen?
Also wenn man noch keinen VPN, Fileserver, ... hat?

Meine Idee war jetzt: z.B. OpenVPN auf einem Azure Server/Container aufsetzen,
über den connecten sich die Clients. (Oder gibt es da was fertiges, mit dem ich per Azure AD-Daten mich ins VPN einwählen kann?)
Darin dann die ganzen Azure Server/Container einbinden (über Azure VPN Verbindung) auf denen die Firmenanwendungen, Shares,... laufen.
Würde man das so machen oder gibt es da eine bessere Herangehensweise?

==> ich will dass sich die Clients nur per VPN verbinden und eigentlich gar nicht merken dass das komplett über Azure läuft

Von genau seinem Beispiel,
angenommen ich will mit der ASP.NET Anwendung auf dem selben Host auf Dateien oder ähnliches zugreifen. Würde man dann eine zweite Anwendung schreiben mit der die ASP.NET Core Anwendung kommuniziert und die das erledigt oder nochmal ganz anders?

Angenommen ich will das so machen, wie würde man das machen?
Eine seperate Anwendung, die lokal einen HTTP API Endpoint aufmacht und intern queuing benutzt? Und die dann halt mit der ASP.NET Anwendung ansprechen? Oder gibt es da ein bessere Protokoll dafür?

Muss sie doch wenn mit der App auf verschiedenen Rechnern auf dieselbe DB
zugegriffen werden muss, ich wüsste nicht wie das anders gehen sollte...?!?!? 8o ?(

Nur die Host App die die API zur Verfügung stellt greift auf die Datenbank zu. Die beiden liegen z.B. auf dem selben System, so dass die Datenbank gar nicht von außen erreichbar ist. Die Clients greifen auf die API zu, damit bekommt auch jeder nur dass was er kriegen darf.

Das hat nichts mit dem ASP.NET Thema zu tun 😉
Ist eine externe Applikation
Aber ja mach ich

Das schöne bei der VM wäre halt gewesen dass man sich mit dem Firmenaccount einloggt + 2FA und nur über den WebClient Zugriff hat.
Das geht auch mit AAD und OpenIdConnect/OAuth2 bzw. der integrierten Security vom AppService.
Letzteres ist aber proprietär. Ich persönlich finds nicht so toll; aber super einfach zu entwickeln (Google nach Azure Easy Auth).

Okay danke dir, dann werde ich das mal so ausprobieren mit den 200$. Wenn ich ein Problem habe melde ich mich nochmal 👅

Interessante Diskussion, ich bin auch ehr der Meinung dass die Daten bei OneDrive z.B. sicherer sind als meine Nextcloud Installation im Keller mit offenem Port nach außen 😄 ich kann da aber T-Virus auch verstehen, wenn man sagt man will seine Daten nicht bei Dritten haben.

Bzgl. meinem Problem:
Wir haben keine feste Infrastruktur, wir nutzen Office365 Business und würden das dann natürlich direkt mit Azure koppeln, wenn das geht mit diesem Online Office AD, etc...
Im speziellen geht es jetzt um ein Rechnungsprogramm das dann möglichst abgeschottet laufen soll.
Der Zugriff auf einem auf Azure gehosteten Container erfolgt ja wahrscheinlich über einen öffentlichen Port. Das schöne bei der VM wäre halt gewesen dass man sich mit dem Firmenaccount einloggt + 2FA und nur über den WebClient Zugriff hat. Wie könnte man das so bei einem gehosteten Container gestalten? VPN Server lokal aufbauen und bei dem Azure einbinden und über den zugreifen?

sorry hab falsch gedacht,

ich glaube die Grafiken werden jedesmal neu gezeichnet,
es gibt immer nur die eine Linie, siehst du ja im Code, das müsstest du ändern, dass die Pfade gespeichert werden, in einer Liste, etc.

Hi,

ich denke hier sind einige aktive Nutzer von Azure dabei, dazu hätte ich mal eine Frage.

Ich möchte eine Web Anwendung im Unternehmen einführen. Diese Anwendung wird sehr selten nur von einzelnen Mitarbeitern benutzt, parallele Nutzung kommt eigentlich nicht vor. Die Daten sollen so sicher wie möglich liegen.
Eignet sich sowas für Azure oder lieber lokaler Host? Ich habe gesehen man kann eine VM anlegen oder auch direkt Docker Container anlegen und die Ports ggf. frei geben.
Könnte ich die Anwendung z.B. auf einer VM installieren und nur intern zugreifen? Also gibts da einen Web Client für die VM oder läuft das nur über offene Ports und RDP?

Angenommen die Anwendung wird effektiv drei Stunden im Monat benötigt, kann ich die VM einfach ausschalten, fallen dafür noch kosten an?

Ja so sehr habe ich mich noch nicht damit beschäftigt, da ich noch ziemlicher ASP Anfänger bin und das von WinForms, etc. noch gewohnt bin.

Also wäre es deiner Meinung der eleganterer Weg z.B. so vorzugehen:

    services.Configure<PositionOptions>(Configuration.GetSection(
                                        PositionOptions.Position));

Und die Konfiguration im Manager so auszulesen:

ErpManager(IOptions<PositionOptions> options)

Oder?
Trotzdem komisch wieso er den Konstruktur mit dem Interface nicht ausgeführt hat, ohne das Interface als Parameter ging es. Per DI konnte ich trotzdem darauf zu greifen.

Aber ich denke dann werde ich von Config.Net komplett auf den eingebauten wechseln.

Ist Config.Net nicht genau dafür da? Also das ich die App.config einlesen kann aber auch andere Quellen?
Sollte die auch in Program.cs mit rein?