Anstelle dem new DateTime(2022, 1, 1) würde ich gerne LicenseManager.GetExpirationDate() haben. Wie greife ich innerhalb des ConfigureServices auf einem Service zu? Oder sollte ich das nochmal anders designen?
ich möchte eine ASP.NET Core Anwendung mit einem License Framework ausstatten (https://github.com/dnauck/Portable.Licensing/). Schutz vor Reverse Engineering oder strenge Prüfungen spielen keine Rolle.
Jetzt würde ich mir gerne eine Klasse schreiben, die mittels Portable.Licensing checkt ob es noch in der lizensierten Laufzeit ausgeführt, max. User, etc. Diese Klasse würde ich dann wieder als Service registrieren um in den Controllern darauf zugreifen zu können.
Jetzt meine Frage bzgl. Laufzeit: das Programm soll z.B. bis 31.12.2021 lizensiert sein.
An welcher Stelle bietet es sich an das zu prüfen? Vielleicht hat jemand sowas ähnliches in der Praxis gemacht und kann sagen wie er es bewerkstelligt hat.
Auf anderen Seiten habe ich gelesen, es in OnActionExecuting zu prüfen und bei einer ausgelaufenen Lizenz eine Exception zu werfen. Ist das sinnvoll bei jedem Aufruf zu prüfen bzgl. Performance,...? Oder sollte es bei wichtigen Funktionen (z.B. /Auftrag/Create) geprüft werden und da dann ein Fehler ausgegeben werden?
Neben diesem Effekt mit dem leeren String ist mir noch etwas aufgefallen. Wenn ich in "Windows Fax- und -Scan" im TreeView daneben auf einen Ordner klicke und das ListView mit anderen Daten gefüllt wird, und ich danach wieder zurück wechsle, so werden wieder die alten Daten im ListView angezeigt und mein "leerer Wert" in der Zelle ist wieder überbügelt mit dem alten Wert.
Die Frage ist, schaffe ich es durch das LVM_SETITEM überhaupt, die eigentlichen Daten des ListView abzuändern? Auf der Festplatte heißt die Datei bereits anders, wird aber mit dieser Aktion im ListView immer noch mit dem alten Wert angezeigt. Scheint so, als ob das ListView hier etwas cached und ich müsste diesen Wert ja irgendwie abändern.
Höchst wahrscheinlich nicht, das ist ja nur die Anzeige der Daten, glaube nicht dass das über das ListView läuft. Würde vermutlich auch so nicht funktionieren.
Die Frage ist ob es sich rentiert.
Habe Identity jetzt soweit eingebunden, aber halt über serices.AddDbContext
Vielleicht belasse ich es erstmal für User in einem separaten Context, da es eh nur wenige User gibt und ein einziger Admin diese nur bearbeitet.
ich greife auf eine Datenbank über einen eigenen Service zu, d.h. dass das eigentlich recht abgekoppelt von ASP läuft. Jetzt möchte ich einen ganz simplen Login Mechanismus einbauen. (ohne Registrierung, Passwort vergessen, etc.)
Hierfür wäre ja Identity ganz sinnvoll, in den meisten Beispielen wird aber recht viel mit dem Grundgerüst Generator, etc. gemacht. Außerdem wird wieder die eingebaute Contextverwaltung genutzt:
Wie baue ich das am besten um, um einen eigenen Service zu nutzen? Oder ist es empfehlenswert für Userdaten den eingebauten Service zu nutzen?
Ich bin noch etwas Flask-User (Python) gewöhnt, da war das extrem einfach und anpassbar, in ASP.NET kommt mir das alles immer ziemlich überladen vor.
Ein paar Funktionen (zum Teil eigene Views und Teile von Views) sollen je nach Lizenz verfügbar sein. Die Frage ist ob das dann über den Controller mache, der Zugriff auf den License Service hat oder ob ich diese Module direkt auslager und je nach Bedarf gar nicht mit an den Kunden gehen. Und dann halt beim Programmstart dynamisch geladen werden.
Denke aber werde erstere Variante machen.
Kannst du irgendein größeres Open-Source ASP.NET Core Projekt empfehlen, was man sich auch mal zum lernen anschauen kann? Also was auch ordentliche Schichtentrennung fährt, Services nutzt, usw. Oder ein Buch zur Architektur von größeren Projekten, etc.?
Viele Grüße!
Dazu mal eine ähnliche Frage,
zur Architektur von umfangreichen ASP.NET Anwendungen:
Habe zwar keine große Logik drin allerdings wird es mit immer mehr Controllern und Views sehr unübersichtlich. Sollte man die Views/Controller auch auslagern und einbinden wie oben? Oder wie entwirft man sowas am besten?
sorry das ich den Thread nochmal rausgrabe, habe aber zur Eingangsfrage noch mal ein Problem.
public class Order
{
public int Id { get; set; }
public string Title { get; set; }
public int CustomerId { get; set; }
public Customer Customer { get; set; }
}
public class Customer
{
public int Id { get; set; }
public string Name_Last { get; set; }
public string Name_First { get; set; }
public List<Order> Orders { get; set; }
}
Ich hätte gerne einen JSON Exporter der Objekte exportiert, dabei entsteht aber eine Zirkularität Order <-> Customer. Und mit den Include() wird es bei immer mehr Objekten (z.B. Order hat List<Article>,...) auch immer komplexer.
Jetzt meine Frage, wie designe ich das am Besten? Lasse ich bei den Models dann die ganzen Lists (List<Order> bei Customer,...) weg und verweise nur noch im Order-Objekt auf die Customer Id, sdass ich da keine Zirkularität bekomme?
In der ASP.NET Anwendung habe ich außerdem mehrere ViewModels, z.B.:
public class CustomerViewModel
{
public int Id { get; set; }
public List<OrderViewModel> OrderViewModels { get; set; }
[Display(Name = "Full Name")]
public string FullName{ get;set; }
public CustomerViewModel(Customer customer){
this.FullName = customer.FullName;
this.Id = customer.Id;
...
}
}
Fülle ich z.B. hier die OrderViewModels dann im Controller oder sollte das eine Schicht darunter passieren? Habe allerdings nur im Controller Zugriff auf den Service.
var model = new CustomerViewModel(_service.GetCustomerById(Id));
...
model.OrderViewModels.Add(_service.GetOrdersFromCustomerId(Id));
...
habe nochmal eine ähnliche Frage zur der Services Thematik:
Ich wollte mit der Config.Net Library Einstellungen verwalten, die habe ich so eingebunden:
// Add settings:
services.AddScoped<ISettings>(_ => new ConfigurationBuilder<ISettings>()
.UseIniFile("config.ini")
.Build()
);
Wenn ich den Dateiname so angebe greift es im Projektordner (nicht bin/Debug) auf die Datei zu (mit IIS Express). Wie gibt man solche Dateinamen am besten an? Hintergrund ist, ich möchte diese INI Datei dann im Docker Container mounten, dass es jeder unkompliziert konfigurieren kann, ohne app.config, etc.
Danke für deine schnelle Antwort und die Info.
Also das Projekt wird eine Firmeninterne Software, die soll am besten mal in nem Docker Container laufen, auf den nur innerhalb des Firmennetzes zugegriffen werden soll. Die Bilder will ich da außerhalb speichern/verwalten, z.B. mit diesem Minio. Entweder in einem separaten Docker Container oder halt auf einem externen Server (aber auch im Intranet), je nach Beanspruchung.
Ich denke für dieses Vorhaben würde auch Docker reichen, sollte es nicht, könnte ich ja einfach den Blob Storage ohne Docker direkt auf einem extra Server einrichten oder?
angenommen ich habe ein ASP.NET Projekt mit dem ich Mitarbeiter verwalten kann und auch Bilder von Mitarbeitern hochladen kann. Also ein Mitarbeiter-Objekt hat dann ein zugehöriges Bild.
Die Frage ist wie verwaltet man das am effizientesten wenn die Bilder recht groß sind und wenn es recht viele Mitarbeiter Objekte geben kann?
SQL BLOB ist ja wahrscheinlich nicht gerade die schönste Lösung. Wie würdet ihr vorgehen?
In der ASP.NET Anwendung das Bild auf dem Dateisystem abspeichern und selbst verwalten?
Was noch eine Idee von mir wäre, man erstellt einen externen Dienst mit REST API, an den leite ich die Bilder weiter und der gibt mir dann bei der Abfrage eines Bildes die JSON Antwort mit seiner URL des Bildes und des Thumbnails. Das könnte dann in einem seperaten Docker Container und damit zur Not einfach auf einem zweiten Server laufen. Gibt es da schon was fertiges in der Art?
Vielen Dank für die Informationen!
Versteh ich das richtig, das überschreibt beim Build dann die einzelnen Assemblyversionen?
In der Anwendung selbst greif ich wie normal auf die Versionsinformationen zu?
angenommen ich habe eine Anwendung, die aus einer Projektmappe mit einer ASP.NET Core Anwendung und entsprechend vielen Bibliotheken besteht.
Geht man beim Release Build dann alle Assemblyversionen durch und ändert die oder wie automatisiert/standardisert man das am besten?
Am liebsten hätte ich einen Versionsstring z.B. "2020_V7_0001". Wie implementiert sowas? Extra ne Bibliothek die sich um die Versionierung und evtl. Updateprüfung kümmert?
nochmal eine kleine Frage ob ich es richtig verstanden hab:
Ich habe diese zwei Objekte, mit denen arbeite ich z.B. in meinem Service, Context, etc.
public class Order
{
public int Id { get; set; }
public string Title { get; set; }
public Customer Customer { get; set; }
}
public class Customer
{
public int Id { get; set; }
public string Name_Last { get; set; }
public string Name_First { get; set; }
public List<Order> Orders { get; set; }
[Display(Name = "Full Name")]
public string FullName
{
get
{
return Name_Last + ", " + Name_First;
}
}
}
Für die erstelle ich dann jeweils ein ViewModel z.b:
public class CustomerViewModel
{
public int Id { get; set; }
public List<OrderViewModel> OrderViewModels { get; set; }
[Display(Name = "Full Name")]
public string FullName{ get;set; }
public CustomerViewModel(Customer customer){
this.FullName = customer.FullName;
this.Id = customer.Id;
...
}
}
Darin habe ich dann nur was der Anwender in der Asp.net Anwendung sehen muss?
Im Controller mappe ich die Customer Objekte auf die ViewModels (bzw. AutoMapper) und gebe die dann z.B. an den View weiter.
Ist das soweit richtig? Gibt es da noch eine bessere ERklärung warum man das so macht? Bei allen ASP.NET Tutorials greifen die direkt auf z.B. Customer zu.
Scoped "lebt" dann solange wie der Client verbunden ist, ist dann mit Context schlauer?
Transient würde dann bei jedem Refresh einen neuen Context erstellen, hab ich das richtig verstanden?
Falls jemand das gleiche Problem hat, mit Parameter:
services.AddTransient<ICustomerService>(s => new CustomerService(new CustomerContext()));
Noch eine Frage zu deinem Beispiel Code,
du erstellst den View dann auch in einer extra "Schicht" oder?
Also in der ASP Anwendung ist so zusagen außer den jeweiligen Funktionsaufrufen fast gar keine Logik?
Du kannst auch einfach eine static Klasse machen mit einer List<Einnahme>() auf die beide Formen zugreifen können.
Die kannst du dann serialisieren/deserialisieren um die Daten lokal zu speichern.
Mit nem DataGridView auf jeder Form mit jeweils der Liste als DataSource kannst du es auch einfach bearbeiten.