Moin zusammen,

habe aktuell die Situation, dass ich ich verschiedenste IEnumerables nutzerseitig filtern lassen möchte (konkret geht es um nen Blazor component der für bereits geladene IEnumerables eine zusätzliche Filter-Funktion bereitstellt).

Nix kompliziertes nur ein bisschen Linq, wobei ich eben die Möglichkeit möchte das Filtern etwas googlelike zu gestalten. Sprich Wenn etwas in Anführungszeichen geschrieben wird, wird nach dem ganzen Text gesucht, andernfalls wird nach jedem einzelnen Wort gesucht, wenn etwas mit % beginnt oder endet wird nach Contains anstatt Equal gesucht etc.

Technisch alles nichts besonders und relativ einfach umzusetzen, aber eben ein wenig Handarbeit. Da ich verschiedene Objekte durchsuchen, will war die Idee eine Helper Library zu schreiben die generics aufnimmt und einfach jede Property vom Typ string durchsucht (oder eben die Properties die explizit eingeschlossen/ausgeschlossen sind).

Die eigentliche Frage daher, bevor ich mich jetzt selbst hinsetze und was zusammenschreibe: Kennt Ihr irgend ein package, was das wie beschrieben oder so ähnlich bereits kann?

Finde online leider wenig dazu bzw. eine endlose Fülle an Seiten die einem erklären wie das technisch grundsätzlich ginge in der die von mir gesuchten Ergebnisse wohl untergehen.

Beste Grüße

Timm

Hab gerade festgestellt, dass MultipartFormDataContent auch IDisposable implementiert.
So funktioniert es jetzt:

   async Task FetchAndUploadFiles()
   {
      var files = await GetFileListFromSomewhere();
      using(var formData = await _iServiceA.BuildFormData(files))
     {
        await _iServiceB.UploadFormData(formData);
     }
     //delete files
   }

Schätze ich hab in meiner ersten Implementierung die einzelnen FileStreams irgendwie squishy gehandled.

Moin zusammen,

hab mal eine Frage die ein bisschen ins Verständnis von Tasks geht:
(Vereinfachte) Ausgangslage: Hab eine List<string> die zu verschiedenen Dateien führen, diese sollen in einen MultipartFormDataContent gepackt und dann via httpclient.PostAsynch hochgeschickt werden und danach gelöscht werden.
Von der Struktur her in etwa so:

interface IServiceA
{
   Task<MultipartFormDataContent> BuildFormData(IEnumerable<string> filePaths);
}

interface IServiceB
{
   Task UploadFormData(MultipartFormDataContent formData);
}

class ServiceC
{
   async Task FetchAndUploadFiles()
   {
      var files = await GetFileListFromSomewhere();
      var formData = await _iServiceA.BuildFormData(files);
      await _iServiceB.UploadFormData(formData);
   }
}

Hier ist jetzt die Frage wie der beste Weg ist dies anzugehen:
Wenn ich das File.Delete direkt hinter den UploadFormData() packe sind die Dateien natürlich vom Prozess noch blockiert.
Für eine einzelne Datei würde ich einfach ein using-Statement für den FileStream um die Methoden setzen und danach löschen.
Wenn ich allerdings X Dateien habe ist mir nicht ganz klar wie hier der saubere weg aussieht.

Beste Grüße
emuuu

Moin zusammen,

ich habe ein kleines Problem bzgl der Serialisierung in eine XML Datei:
Konkret habe ich die Klasse TestProbe (mit einer inneliegenden Baumstruktur die hierfür aber egal ist). Diese möchte ich in eine XML-Datei konvertieren die ein Zielprogramm einlesen kann.
Das Zielprogramm verlangt nun, dass das Root-Element TestProbe mit einigen Namespaces daher kommt:

<TESTPROBE xmlns:cm="http://www.sparkworks.com/Common-Measurement-xml" xmlns:sl="http://www.sparkworks.com/TestProbe-Language-xml" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.sparkworks.com/TestProbe-Database-xml">
</TESTPROBE>

Inhaltlich haben die Namespaces für meinen Teil des Systems keinerlei Relevant (ich könnte also im Prinzip im Convert am Ende die Datei um die Textpassagen ergänzen), möchte das aber natürlich sauber lösen.
Und ganz im Ernst: Ich habe keine Ahnung wie. Ich recherchiere nun den halben Tag an XML-Attributen herum (zugegeben nicht mein Fachgebiet) und kriege es einfach nicht hin, dass der Konverter genau diese genau so ins Element schreibt.

	[XmlRoot(ElementName = "TESTPROBE", Namespace = "http://www.sparkworks.com/TestProbe-Database-xml")]
	public class TestProbe
	{
	//...
	}

Der Namespace (sowie die XMLSchema-Instance) werden auch problemlos eingefügt aber eben die LocalNames ("xmlns:cm", usw) nicht.
Ich habe es unter anderem schon mit diesem Ansatz versucht:

		[XmlAttribute(AttributeName = "cm", Namespace = "xmlns")]
		public string CommonMeasurement{ get; set; }

Leider ohne Erfolg.
Bin für jeden Rat dankbar, wobei mir schon ein paar Stichworte in die richtige Richtung helfen würden.

Beste Grüße
emuuu

In der Praxis findet aber HATEOAS kaum Anwendung, weil es schon auch große Nachteile hat:

Super erstmal danke für die Hinweise. Hab mir bewusst ein kleines Projekt gesucht, wo eine mögliche Überkomplexität, am Ende keine Beine bricht. Ich will vor allem ein Gefühl für Nutzen und Aufwand kriegen, um im Zweifel dann dafür oder dagegen argumentieren zu können.

Ansonsten weiß ich nicht, was Du mit Geschäftslogik meinst; denn in de Links wird nur der State übertragen.

Damit meine ich ganz platt in welcher Form die Informationen innerhalb der API weitergereicht / zusammengetragen werden.
Wenn ich z.B. in einer response die Links von drei verschiedenen Controllern habe und bei einem nested object kann der user aufgrund der authorization editieren, bei zweien deleten und die restlichen nur get.
Ich weiß momentan nicht an welcher Stelle in der API ich die Kenntnis über alle möglichen Links + die Authorization zusammentragen würde.

Gib Deine API Klassen niemans ein Suffix wie DTO, sondern arbeite einfach mit einem spezifischen Namen wie "Product" und einem sauberen Namespace.

Wie siehts da mit z.B. create- und update-klassen aus? ProductCreate, ProductUpdate?

Wenn ich für unterschiedliche authorization unterschiedliche Details ausgebe (bsp Kunde kann nur Name, Preis, etc sehen, Produzent die Parts, Teilenummer, usw.):
Ich verwende dafür unterschiedliche Klassen Product, ProductForManager. Wie verträgt sich das mit doc discovery?

Guten Tag zusammen,

wie der Titel schon sagt beschäftige ich mich momentan mit authorization aware hateoas (tl;dr; anstatt alle möglichen transitions gibt der server nur die im aktuell authorization context gültigen transitions zurück -> Kunde kann Produkte abfragen aber nicht updaten)
und würde das in einem neuen Projekt gerne anwenden. Das Grundprinzip ist ja relativ simpel.
Meine Frage wäre nun, ob wer von euch damit schon Erfahrungen hat und optimalerweise irgendwelche examples hat / kennt.

Mich interessiert dabei vor allem die Projektstruktur und Zugriffsebenen:
Die Links kennt imho nur der Controller die Authorization hingegen liegt um untergeordneten business layer.

Und wie sieht es mit nested objects aus? Wenn ich bsp folgendes Dto habe:

public class ProductDto
{
   public int Id {get;set;}

   [..]

   public IEnumerable<PartDto> Parts {get;set;}
}

Mir ist noch nicht ganz klar, wie ich die Information über die möglichen transitions (die beim PartDto z.B. aus einem anderen Controller kommen als für ProductDto aufgerufen wurde) in die Geschäftslogik und wieder zurück kriege (ohne gegen Konventionen zu verstoßen).

Natürlich wird es hier nicht den einen richtigen Weg geben und es ist immer von den weiteren Anforderungen anhängig. Aber mir fehlts dahingehend momentan an einem Grundgerüst, das man weiterentwickeln kann.

Beste Grüße
emuuu

Wundert mich, dass es noch keine News dazu gab, darum hier in aller Kürze:
Heute launched .NET 5 auf der .NET Conf 2020 :]

Für eine "richtige" Cross-Plattform-UI soll MAUI kommen, aber das steht noch aus.
Xamarin kann nach meinem letzten Stand nur mobile Geräte, keinen Desktop und wird nach .NET 6 auch recht bald sein Ende finden, da es ja durch MAUI abgelöst werden soll.

Xamarin kann mit Forms iOS, macOS, Android & UWP ist also stand jetzt schon absolut Cross-Plattform fähig. Du kannst damit quasi auf alles aktuelle außer Linux & exotische Smartphone OS (e.g. HarmonyOS von Huawei).
Habe eine App die ich problemlos auf einem Windows-PC ebenso wie auf einem iPhone deployen kann.

MAUI löst Xamarin auch imho nicht ab sondern ist ein rebranding (Microsoft hat Xamarin gekauft und schließt damit quasi die Einbindung in die eigene Produktfamilie ab).
Unter der Haube wird sich nicht allzu viel ändern.

ganz schön freche antwort wenn man bedenkt das man dir helfen will. ich denke du kannst es einfach nicht kapieren oder willst es nicht kapieren.

Ich empfinde deine Antworten eher als extrem herablassend und mit gefährlichem Halbwissen gespickt.

Kilo hat 10 bytes also heisst es ausgesprochen 2 hoch 10 Bytes = 1024 Bytes

Das ist vollkommener Quatsch. Man sagt zu 2^{10 Bytes wie ayykaramba schon richtig gesagt hat einfach umgangssprachlich Kilo, weil 10}3 am nächsten dran an 2^10 ist. Und die SI-Präfixe waren damals einfach extrem verbreitet und daher hat sich das durchgesetzt.

Mit dem Aufkommen der TB-Festplatteten haben die Hersteller sich das direkt zu nutze gemacht und bei einer 1 TB-HDD nur 1000 GB anstatt 1024 GB reingepackt.

Moin zusammen,

bin gerade über dieses schöne Repo zum Erstellen eines Widgets, welche die Corona-Fallzahlen + die Inzidenz für den Aufenthaltsort anzeigt, gestolpert:
incidens_and_newcases.js

Ihr benötigt dafür die App Scriptable (eine genaue Anleitung ist im gist enthalten)

Ich kenne mich mit Android-Widgets nicht aus, aber da das Script in js ist, sollte es sich relativ leicht für Android anpassen lassen.

Beste Grüße
emuuu

Edit:
Hier ist der Original-Code der auch zahlreiche Forks mit verschiedenen, fertigen Varianten (mit Bildern) auflistet.