Git hat den Fokus auf Integration, svn auf Kollaboration
Wirklich? Gerade für Kollobaration -- für mich das Zusammenarbeiten mehrer Entwickler

Der Satz ist nicht von mir, sondern von einem guten Freund aus dem svn-Kernentwicklerteam bei Apache 😉. Ich stimme ihm da aber zu. Was gemeint ist: natürlich sind beides Tools, die u.a. die Zusammenarbeit mehrerer Entwickler fördern wollen. Aber die Philosophie, wie das erreicht werden soll, ist bei beiden ziemlich unterschiedlich: git legt den Fokus auf die Integration der Änderungen verschiedener Entwickler. Es ist bei git echt leicht, einzelne Änderungen abzuweisen oder rückgängig zu machen. Die meisten Probleme, die mit SVN auftreten, beziehen sich auf genau das - das merging, also die Integration von Änderungen, ist svn etwas hinterher. Git ist stark, solange die Änderungen pro Entwickler atomar sind. Wenn mehrere Entwickler zum selben Problem am selben Stück Code Änderungen vornehmen wollen, wird es hakelig (und so sollte man git auch nicht verwenden). SVN kommt mit so etwas super klar, dort kann und soll man sogar so arbeiten.

Git integriert Änderungen verschiedener parallel an verschiedenen Problemen arbeitender Entwickler besser. SVN unterstützt parallel am gleichen Problem arbeitende Entwickler besser. Soweit ich das beobachten kann, geht der Trend definitiv zu ersterem, weil zweiteres den Bau von Monolithen begünstigt.

LaTino

Ich frage mal ganz kleinlaut: Gibt es einen Grund warum hier noch SVN statt Git genutzt wird?

Git hat den Fokus auf Integration, svn auf Kollaboration. Klar machen am Ende des Tages beide das gleiche, aber die unterschiedlichen Ansätze machen sich bemerkbar, und für manch einen mag svn angenehmer oder besser in seine Prozesse integrierbar sein. Es ist auch nicht so, dass es nicht mehr entwickelt würde (das betrifft nur AnkhSvn). Außerdem empfinde ich persönlich den Entwicklungsprozess bei Git als komplexer bzw. schwerer zu kapieren, wenn man ihn noch gar nicht kennt.
Hauptsächlich wird der Grund "immer noch" svn zu benutzen, einfach der sein, dass man zufrieden ist und keinen Grund sieht, zu wechseln. Das Tooling halte ich nicht für schlechter als bei git.

LaTino

Normalerweise würde man für den Ansatz eine eigene Stream-Implementierung benutzen, die intern die Sammlung von Streams abgrast. Jedenfalls machen wir das so, ist übersichtlich und wird auch von MS empfohlen. Für den Fall, dass es sich um viele kleine Streams ohne semantischen Zusammenhang handelt, empfiehlt MS dagegen mehrere Requests in einer Session.

The most common scenario in which such large data content transfers occur are transfers of binary data objects that:

Cannot be easily broken up into a message sequence.

Must be delivered in a timely manner.

Are not available in their entirety when the transfer is initiated.

For data that does not have these constraints, it is typically better to send sequences of messages within the scope of a session than one large message. For more information, see the "Streaming Data" section later in this topic.

LaTino
EDIT: @T-Virus es geht, wenn ich das richtig verstanden habe, um Streamed Transfer. Die Frage, ob man Stream verwendet oder nicht, stellt sich also nicht.

WCF: Large data and streaming

@MrSparkle, wenn die Messdaten nur zusammen mit ihrer Herkunft richtig interpretiert werden können, dann gehört diese Info auch zu ihnen. Betonung auf "wenn".
In dem Fall ein Interface IHasSourceInfo, die Datenmodelle davon ableiten und mit einem modifizierten XmlSerializer den Wert einmalig befüllen. Sollte keine große Sache sein.

Wenn du die Info dagegen für die Interpretation der Daten nicht benötigst, sondern zu anderen Zwecken brauchst, ist MrSparkles Ansatz korrekter. Dafür ein geeignetes Datenmodell einführen und gut.

LaTino

"veraltet" ist in diesem Zusammenhang extrem subjektiv. Abt sieht das so, das heisst aber nicht, dass es objektiv so ist. Könnte man streiten, hat man auch schon und führt zu nix.

Dein Problem ist ein konzeptionelles, mit einer anderen Technologie kannst du es umgehen, aber nicht lösen. Stell dir ein paar Fragen:

• sollte Servicehost als Container für die gehosteten services (sic!) wissen, was die Services tun?
• welche Möglichkeiten haben Services, außer über eine statische Klasse Informationen miteinander zu teilen? (Hint: dieselben wie jedes andere Objekt auch.)
• Gibt es möglicherweise Konzepte, die die Erstellung, Zerstörung und Verwaltung von Objekten organisieren?

Wir machen etwas ganz ähnliches in einem Kontext, der (aus unserer Sicht) die Benutzung von WCF erzwingt. Es ist durchaus konkurrenzfähig. Das heisst wäre es, wenn es nicht das einzige zuverlässig funktionierende Produkt auf dem Markt wäre. Und es gab durchaus Versuche durch die Mitbewerber.

LaTino
Edit: noch ein bisschen Lesestoff (es gibt mehrere Ansätze, wie man das Problem lösen könnte. Die Links gehören nicht notwendigerweise zum selben, aber ich halte sie für generell hilfreich für dich):
https://docs.microsoft.com/de-de/dotnet/framework/wcf/extending/extending-hosting-using-servicehostfactory
https://blogs.msdn.microsoft.com/carlosfigueira/2011/06/13/wcf-extensibility-servicehostfactory/
http://scotthannen.org/blog/2016/04/13/wcf-dependency-injection-in-5-minutes.html
https://lostechies.com/jimmybogard/2008/07/30/integrating-structuremap-with-wcf/
(das blog ist generell lesenswert)
...und und und.

Diese Art Nebelgranate ist der Grund, wieso ich das nicht diskutieren wollte.

Nein, ich werfe nichts durcheinander, danke der Unterstellung.

Ich habe lediglich illustriert, wieso man, wann immer man Daten sammelt, davon ausgehen muss, dass sie zum Schaden eines Unschuldigen verwendet werden können. Denn das unterschlagt ihr komplett, weil ihr davon ausgeht, dass

a) der Staat versucht, keine Fehler zu machen
b) Fehler, wenn sie vorkommen, folgenlos gehalten werden
c) die ausführenden Organe makellos sind

Das sind alles Annahmen fern der Realität. Erinnert sich jemand den Polizeibeamten, der aus Neugier die Führungszeugnisse seiner Nachbarn untersucht hat? An den Steuerbeamten, der aus demselben Grund Bankabfragen zu Bekannten veranstaltet hat? Wo ein Trog ist, dort sammeln sich Schweine. Wo Daten gesammelt werden, werden sie missbraucht. Und solche Missbräuche sind in einigen Fällen nicht folgenlos und in einigen Fällen auch nicht wieder gut zu machen. Wer das Sammeln von Daten befürwortet, nimmt das in Kauf. Und das ist ein valider Standpunkt (!), aber man kann sich nicht hinstellen und sagen "wenn man nichts getan hat, passiert einem auch nichts", denn angesichts der Faktenlage ist das einfach eine bewusste Lüge. Ehrlich wäre zu sagen: "ich weiß nicht, ob's was bringt. Probieren wir es einfach aus, und wenn ein paar Unschuldige in die Mühlen der Justiz geraten, dann ist das zum Glück nicht mein Problem". Klingt nur nicht so schön, nicht?

Und es ist schön, dass der Staat zugab, dass ich unschuldig war. Auf dem materiellen, ideellen und gesundheitlichem Schaden bleibt man aber trotzdem sitzen, oder dachtest du, das wird erstattet? Falls ja, habe ich Neuigkeiten für dich.

LaTino

Es gibt wohl auch jemanden, der behauptet, dass Microsoft seinen Code geklaut hat.
Ich habe mir weder den einen, noch den anderen Code angesehen, aber da scheint nichts dran zu sein, wenn man die dort verlinkten Seiten verfolgt.

Ja, die Beweise für die Behauptung werden immer schwächer, je länger man den Thread auf reddit verfolgt. FUD - dass das jetzt einmal Microsoft trifft, ist dann wohl Karma.

LaTino

Reflection:

• Vorteil: neue und entfernte Properties schlagen direkt auf das Ergebnis durch
• Nachteil: wenn einzelne Properties ausgelassen werden oder sonstige Anpassungen erfolgen sollen, muss der Reflection-Helper angepasst werden. Viele von uns haben so eine Klasse schonmal nach ein paar Jahren gesehn, das blickt niemand mehr.

Einzelaufruf pro Property:

• Vorteil: scheller, sicherer Zugriff auf die Properties, die man braucht. Welche Properties man braucht, sieht man direkt im Quellcode.
• Nachteil: führt man neue Properties ein, wird nicht direkt DoSomething für sie aufgerufen. Zusätzlicher Aufwand durch zusätzliche Zeile Code + zusätzlichen Testcase für den Unittest. Werden Properties entfernt, baut er nicht mehr (ob das ein Nachteil ist, lass ich mal dahingestellt).

Kurz gesagt: entscheide dich zwischen Compiletime- oder Runtime-Fehlern. Ich müsste da nicht allzu lange nachdenken.

LaTino

Abwägung zwischen dem Aufwand einer eventuell notwendigen Migration und den durch sie erhofften Vorteilen. Ansonsten - wenn überhaupt nix migriert werden muss - würde ich in dem Szenario von WCF Abstand nehmen, wenn nicht irgendetwas anderes (vorgegebene Schnittstellen, zu erfüllende Spezifikationen...) dagegen spricht.

LaTino
(die von dir genannten Punkte "gehen" immer, der Aufwand ist vergleichbar, die Lernkurven sind unterschiedlich...definitives "das kommt darauf an".)

Das Wissen über die Gesamtzahl der Mitarbeiter gehört nicht in den Aufgabenbereich der Klasse Mitarbeiter (wie im richtigen Leben auch). Führ ein Element ein, dass die Erstellung und Löschung von Mitarbeiter-Objekten in seiner Kontrolle hat (heisst: eine Klasse, die zB über die genannte Liste die Mitarbeiter speichert und als einziges new Mitarbeiter() aufrufen darf). Dort ist dann auch die Anzahl der momentan vorhandenen Mitarbeiter-Instanzen bekannt.

LaTino

Der Zugriff auf eine andere Klasse (A) in einer Methode ist m.E. eine Assoziation, aber da scheiden sich die Geister etwas. Der Sinn von UML ist aber auch nicht, eineindeutig (im math. Sinn) auf Code abgebildet zu werden. Andere sehen nur das hier als Assoziation:

public class B
{
    public void PrivateMethod(A instanceOfA) 
    {
       instanceOfA.Operation();
        //...
    }
}

Aber das hier nicht:

public class B
{
    public void PrivateMethod() 
    {
        A instanceOfA = new A();
        instanceOfA.Operation();
        //...
    }
}

Das kann man sehen wie man will. Deine Teillösung IST eine Assoziation.

LaTino

wenn damit die Auklärungsrate steigt (und das tut sie) was spricht dagegen?

Du fährst im Endeffekt die "ich hab doch nix zu verbergen / wer sich nichts zuschulden kommen lässt, hat nichts zu befürchten"-Schiene und diffamierst gleichzeitig jene, die was dagegen haben, überwacht zu werden, obwohl gegen sie kein Verdacht besteht, als Verschwörungstheoretiker.

Beide Sichtweisen halte ich in einer ernsthaften Diskussion nicht für haltbar, und das ist auch nicht nur meine persönliche Sichtweise. Mich erschreckt nur, dass selbst Softwareentwickler darauf reinfallen, die von Berufs wegen ein besser entwickeltes Gespür für Ethik in der Technologie haben sollten.

(Gleichzeitig hast du bereits zweimal behauptet, die Aufklärungsquote sei durch Kameras gestiegen, was nachweislich falsch ist, wie dir eine kurze Google-Recherche zeigen wird (es handelt sich halt samt und sonders um Argumente, die in -zig Diskussionen schon genausooft widerlegt werden und dennoch immer und immer wieder angeschleppt werden).)

LaTino, raus aus dem Topic

Warum ist das so?

Weil Klasse A von Klasse B in deren Methode Auslesen benutzt wird. Enger muss man die beiden nicht koppeln.

LaTino

Gut möglich, wie ich schrieb - wir leben in einem Rechtsstaat... Nicht mehr in einer Dikatur und ich möchte nicht auf die Anehmlichkeiten der neuen Erungenschaften verzichten nur weil damit auch Schindluder getrieben werden kann.

Was du nicht verstehst: die Tatsache, dass wir in einem Rechtsstaat leben, ist weder selbstverständlich noch für die Ewigkeit. Sondern man - jeder! - muss ununterbrochen dafür sorgen, dass es so bleibt. Stattdessen wird die Basis dieses Rechtsstaates unterminiert, und diese deine Einstellung dazu hilft dabei. Mag sein, dass Kameras nicht das Ende des Rechtsstaates sind. Aber es ist eine weitere Umdrehung am Heizelement für uns Frösche, die wir im warmen Wasser sitzen. Und wenn sich nicht mehr genug Menschen gegen einen übergriffigen Staat wehren, dann werden wir alle die Erfahrung machen müssen, wie es ist, nicht mehr in einem Rechtsstaat zu leben. Und sowohl anlasslose Überwachung zu begrüßen als auch das Abtun von Bedenken als "Verschwörungstheorien" sind kleine Bausteinchen auf dem Weg dahin. Das ist auch, so vermute ich, der Grund, wieso herbivore so empfindlich reagiert hat.

Gerade wir, die daran arbeiten, immer neue Technologien zu erfinden oder zu bauen, MÜSSEN immer hinterfragen, was wir und andere da tun, und was das für Konsequenzen hat. Wer das nicht tut, handelt verantwortungslos.

LaTino

Hier liegt euer Denkfehler - wer sagt euch, dass nicht durch die Anwsenheit von Kameras der Anschlag gar nicht stattfindet - eben weil Kameras da sind. Darüber kann und wird es niemals Statistiken geben...

Jetzt wird es gleich auf mehreren Ebenen absurd.

1. wenn jemand eine Kamera installiert und damit meine Freiheit einschränken möchte, hat er gefälligst den Beweis zu führen, dass die Massnahme wirkt, und nicht ich habe zu beweisen, dass es nichts bringt.

2. Frag die Briten, wie erfolgreich ihre extrem hohe Kameradichte Anschläge verhindert.

3. Wer sich durch Kameras abschrecken lässt, hat Angst davor, was passiert, wenn er geschnappt wird. Ich wage zu behaupten, dass religiöse Fanatiker nicht in diese Kategorie fallen. Genauso gut könntest du längere Gefängnisstrafen für Selbstmordanschläge fordern.

4. Die Falschpositivrate bei der automatischen Suche liegt bei 92%.(https://www.heise.de/tp/features/Gesichtserkennung-von-Menschenmassen-mit-einer-Fehlerrate-von-92-Prozent-4042982.html) Und dafür soll meine Freiheit im öffentlichen Raum eingeschränkt werden?

Mag sein, ich bin empfindlicher, weil ich in einer Diktatur aufgewachsen bin und weiss, wie sehr man sich als Frosch an heisser werdendes Wasser gewöhnen kann. Aber wenn man seine Freiheiten freiwillig abgibt, hat man sie nicht verdient.

LaTino

Die Technologie kommt von einem privaten Unternehmen - wird aber nicht von privaten Unternehmen genutzt.
Das finde ich auch nicht schlimm.

Solange man Vertrauen in den Staat hat (und das gerechtfertigt ist), ist das vielleicht nicht schlimm, könnte man diskutieren. Aber erstens verbietet niemand den privaten Unternehmen, ihre Software auch an andere Staaten zu verkaufen [1], und zweitens gibt es niemals eine Garantie dafür, dass ein Staat auch immer vertrauenswürdig bleibt.

So gesehen, ist es dann doch wieder schlimm.

LaTino

[1] http://www.sueddeutsche.de/digital/ueberwachung-deutsche-spaeh-software-gegen-tuerkische-oppositionelle-eingesetzt-1.3979824

Blöd nur, dass Menschen ihr Verhalten schon ändern, wenn sie nur davon ausgehen müssen, von einer Kamera erfasst zu werden. Und ich rede nicht davon, dass sie eben nicht mehr bei Rot über die Ampel gehen, sondern dass sie Verhaltensweisen, von denen sie glauben, sie erscheinen unangepasst, von vornherein abstellen. Völlig unbewusster Vorgang.

Und tschüss, individuelle Freiheit.

LaTino

Es ist sogar so, dass Microsoft selbst HTTP nur als Middleware in ASP.NET Core implementiert hat

Daher "per sé". Von MS selbst ist die Implementierung in ASP.NET Core die einzige (edit: mir bekannte).

LaTino

Was ist eure Erfahren mit RPC/IPC und/oder MessageBus-based Kommunikations-"Frameworks" in .NET Core ?

Wir haben in einem Anwendungsfall ein bisschen evaluiert (zeroMQ, netMQ, Rabbit) und die Versuche zugunsten von asp.net core eingestampft. Zu unausgereift, zu unvollständig, teils überkomplexe Lösungen für einfache Probleme war das Fazit in etwa. Nun war das vor fast einem Jahr, mag sein, dass sich seitdem was getan hat.

LaTino

Das WCF weg fällt ist gekauft. Allerdings, dass es immer eine WebAPI sein muss, würde ich nicht so stehen lassen (bzw. würde ich das gerne mich euch diskutieren - wenn Ihr Zeit und Lust dazu habt).

Um ganz ehrlich zu sein, sehe ich da wenig Raum für Diskussion. .net core unterstützt per sé erst einmal nur http-basierte Kommunikation. Wenn man das diskutieren möchte, ist das gleichbedeutend damit, dass man gern seinen eigenen Kommunikationsstack in .net core implementieren möchte. Dafür sehe ich weder eine Notwendigkeit, noch einen Nutzen.

LaTino

Inwiefern widerspräche denn bitte das Verwenden von asp .net core dem Verwenden von HTML 5?
Wie deine Views aussehen, bleibt immer noch dir überlassen...

LaTino

Natürlich möchte ich kein "SOAP+REST" ... um Gottes willen.

Als Roy Fielding REST das erste mal beschrieben hat, tat er das als SOAP+REST, keine Rede von "um Gottes Willen". Es wäre eine (inzwischen) seltene, aber gangbare Variante.

Vielleicht habe ich das nicht deutlich genug beschrieben.
Ziel ist es natürlich WCF (und somit auch SOAP) zu ersetzen.

Wenn ihr .net core einsetzen wollt, fällt WCF sowieso weg, und es muss eine WebAPI sein, weil ALLE .net core-Anwendungen im Grunde eine WebAPI sind*. Die Diskussion könnt ihr euch also sparen.

(@BhaaL: ja, hin und wieder wird mal öffentlich erwogen, auch die serverseitigen Aspekte von WCF zu portieren. Glaub ich erst dran, wenn ich es sehe, zumal sowas aus meiner Sicht der Zielstellung von .net core widerspräche.)

Das Design der API RESTful oder als RPC hängt im Wesentlichen davon ab, ob die durch die API integrierten Prozesse als Statuswechsel beschrieben werden sollen oder nicht. Also keine Frage des Geschmacks, sondern der Anwendung.

Parallel fallen auch einige der genannten message-Protokolle weg, schlicht weil sie .net Standard nicht unterstützen. Unklar ist darüber hinaus, welche Notwendigkeit für diese Protokolle überhaupt besteht. Der Einsatz sollte schon gut begründet sein, sonst hat man nur einen Komplexitätsgewinn ohne Nutzen.

LaTino

• i.e. eine API, die auf HTTP(s) und TCP basiert.

Ist ein bisschen unklar, was du vor hast.

Callbacks (nicht nur unidirektionale calls, sondern die Clients senden an den Server)

Das ist kein Callback, sondern normale Client-Server-Kommunikation. Client benutzt API.

Du möchtest, dass der Server von sich aus den Client anspricht? -> SignalR

Möchtest du den Application Layer gleich mit wechseln? Oder soll der Austausch so passieren, dass die Clients das nicht merken? Und wenn ja, verstehe ich das richtig, dass du auf SOAP+REST möchtest (exotisch, geht aber)? Oder verwechselst du da Anwendungsprotokoll (SOAP) mit API-Architektur (REST)?

Und was haben deine Stichpunkte unter "schnelle Antwort" mit deinem Wunsch zur Migration nach .NET Core zu tun?

Bitte etwas ausführlicher, so wird kein Mensch schlau draus. Ich jedenfalls nicht.

LaTino

1. ArrayList bitte durch etwas Geeignetes ersetzen. Die Klasse ist seit 2005 obsolet.
2. Visual Studio -> Debuggen -> Fenster -> Ausnahmeeinstellungen
3. Haken in der zweiten Zeile "Common Runtime Exceptions" setzen
4. Projekt mit F5 starten

Siehe auch: [Artikel] Debugger: Wie verwende ich den von Visual Studio?

Bevor der Handwerker anfängt zu arbeiten, sollte er seine Werkzeuge beherrschen 😃

LaTino

Klingt für mich eher nach Java Web Start. Ob man das wirklich verwenden will, lass ich mal dahingestellt.

LaTino

Aber wegen den 40 IF. Da hab ich keine Idee, wie es anderes funktionieren könnte.

Weil das ein ziemlich häufig vorkommendes Problem ist, und weil es ein Problem ist, das die Organisation des Codes betrifft (und nicht die Funktion, deine Variante tut ja, sie ist nur sch....lecht zu warten und zu lesen), gibt es dafür erprobte, funktionierende Vorgehensweisen. Eine gut funktionierende (und nicht zu komplexe) hat Palin genannt, an deiner Stelle würde ich mir auch mal Command und Chain of Responsibility anschauen. Selbst, wenn du sie für zu komplex hältst: man wird kein schlechterer Programmierer, wenn man sie kennt 😉.

LaTino

Durch Anwenden. Einige der C# 7-Features muss ich immer noch nachschauen, wenn ich sie benutzen will (unsere festgelegte Sprachversion auf Arbeit ist C# 6). Dazu kommt, was schon gesagt wurde: stur auswendig lernen ist in jedem Fall schlechter als ein Feature, das man verstanden hat (Beispiel: "private protected" Klassen. Wenn man verstanden hat, wie die Zugriffsrechte auf solche Klassen aussehen, vergisst man weder, dass es den Modifizierer gibt, noch die Reihenfolge). Das geht natürlich nur mit Sprachen, die in weiten Teilen in sich logisch sind, was mit einer Ausnahme [1] für alle derzeit verbreiteten auch gilt.

LaTino
[1]

let a = function() {
  return "hello";
}

let b = function() {
  return
        "world";
}

alert(a() + b());
//*brechreiz*

Ich habe in einer For-Schleife mehrere IF-Abfragen drin, welche mir einen String auswerten sollen.
Es sollen bis zu 40 Möglichkeiten, welche in dem String drin sein könnten, abgefragt werden und dann jeweils eine Aktion erfolgen.

Abgesehen von continue sind 40 if-Anweisungen schon ein extrem starker code smell. Solltest du dringend überarbeiten. (Außerdem [Tipp] Anfängerhinweis == true / == false)

LaTino

Richer, Justin & Sanso, Antonio: OAuth 2 in Action. Manning Publications Co., 2017. ISBN 978-1-61729-327-6

Nicht nur für Webentwickler!

Die beiden Autoren wissen, wovon sie schreiben, und tun das auch noch prägnant und auf den Punkt:

• Überblick über OAuth 2.0
• detaillierte Erläuterung des "kanonischen" Autorisierungs-Prozesses (authorization code grant type)
• Programmierung eines voll funktionstüchtigen OAuth 2.0-Clients
• Variationen des Protokolls (andere Autorisierungsprozesse)
• Übliche Sicherheitsprobleme und ihre Vermeidung
• JWT und JOSE im Detail
• dynamische Client-Registrierung
• Authentifizierung mit OAuth 2.0 und OpenIdConnect
• UMA in Verbindung mit OAuth 2.0, Anwendungen von OAuth 2.0 in der Industrie (HEART und iGov)
• Beyond JWT: Proof of Possession und TLS token binding

Als Bonus gibt's beim Kauf des Paperbacks (im Handel für unter 30 Euro) das Buch als eBook in beliebigen Formaten kostenlos oben drauf (so muss das sein!) und den kompletten Quellcode der "Übungen" auf github.

Dicke Empfehlung.

LaTino

Da's noch keiner erwähnt hat:

Null Propagation

i.e.:

el?.Element("businessProcess")?.Element("processNumber")

Bei einem string.format ist zudem der cast auf string nicht nur überflüssig, sondern, da's ein "harter" cast ist, auch noch gefährlich. Dazu wäre es ein guter Gedanke, string interpolation zu nutzen.

Zu guter Letzt kann man sich angewöhnen, zu parsendes XML immer zu validieren, bevor man es parst. Entweder das, oder man prüft beim Parsen, ob alle benötigten Elemente da sind (und wenn man das macht, muss an sich fragen lassen, wieso man überhaupt XML nutzt. Validierung kommt quasi kostenlos mit XML...).

Oder man lässt den ganzen händischen Kram und serialisiert/deserialisiert. Ist auch schneller und fehlerfreier geschrieben.

LaTino

Was für mich wichtig ist ich hab eine Arbeit, die mir (meistens) Spaß macht. Ich darf mich mein Leben lang weiterbilden und neue Sachen entdecken. Und werde dafür recht gut Bezahlt. Hätte schlimmer kommen können.

So sieht's mal aus, ich hoffe, für die meisten von uns.

LaTino

Das ist auch kein ungewöhnliches Gehalt für einen Windows-Admin direkt nach seiner Ausbildung. Du bist da offensichtlich etwas verwöhnt 😮).

Als Referenz:

Ein IT Azubi im IG Metall Tarifverbund bekommt i.d.R. ERA 7.
ERA 7 sind in BW 3046€ bei 35 Stunden - ohne Leistungszulage.

Der IG Metall Vertrag sieht hierbei 13,39 Gehälter und 30 Tage Urlaub vor.

Ergo: 40.700€ bei 35h bzw 46.600€ bei 40h

Woah. Interessant. Mir ist hier (Thüringen) keine IT-Bude bekannt, die nach Tarif zahlt. Nicht eine. Vor zwei Jahren bot mir ein Unternehmen aus Jena, bei dem ich mich nicht beworben habe, 42k (ich habe Diplom und >20 Jahre Berufserfahrung) und hielten das für normal und ausreichend für eine Abwerbung. So sieht die Realität hier aus (und ich zahl auch 1200 Euro Miete 😉 ).

LaTino

Und - selbst ein gerade fertig gewordener - Informatikstudent, der sich mit 35k zufrieden gibt, dürfte wohl nicht so leicht zu finden zu sein...

Naja. Weder die derzeitige Beschäftigungslage noch das derzeitige Lohnniveau sind, was ich als "normal" bezeichnen würde. Als zuletzt Kurzarbeit auch in unserer Branche angesagt war, konnte man einen frischen Dipl-Inf. für 24k im Jahr bekommen. Ist dann das andere Extrem.

Zum Thema zurück: wer's wegen des Geldes macht, wird a) nicht glücklich und b) nicht reich. Der Verdienst ist eine Frage von Verhandlungsgeschick, Geschlecht, Region, Spezialisierung, Arbeitsmarkt. Pauschalaussagen bringen da nix 😃. Fakt ist: weder ein Fachinformatiker noch ein Dipl-Inf müssen von der Hand in den Mund leben. Und beide werden nicht von ihrem Gehalt zum Millionär.

LaTino

Nun könnte man die Frage stellen, ob wir überdurchschnittlich gut oder Ihr überdurchschnittlich schlecht bezahlt 😉

Eine Mischung aus beidem. Ich würde keinem Fachinformatiker direkt nach der Ausbildung mehr als 35k anbieten. Das ist auch kein ungewöhnliches Gehalt für einen Windows-Admin direkt nach seiner Ausbildung. Du bist da offensichtlich etwas verwöhnt 😮).

LaTino

Aber verstehen, wo der Codepfad ist, der keinen Wert zurückgibt. Denn wenn beide Schleifen mindestens einmal durchlaufen, komme ich doch immer entweder in if oder in else an.

Das ist etwas, das du weisst. Der Compiler versteht die Signatur von Methoden - was kann rein, was kann rauskommen - aber er weiß nichts über ihre Funktion. Schauen wir uns mal Array.GetLength() an:

Parameter
dimension
Type: System.Int32
Eine nullbasierte Dimension des Array, deren Länge bestimmt werden soll.

Rückgabewert
Type: System.Int32
Eine 32-Bit-Ganzzahl, die die Anzahl der Elemente in der angegebenen Dimension angibt.

Die Methode könnte also negative Werte zurückgeben, wie 123thomas gesagt hat. Man lernt als Programmierer mit der Zeit, den Code auch aus Sicht des Compilers zu sehen und entsprechend defensiv (für alle Eventualitäten, auch die, die gar nicht eintreffen dürften) zu programmieren. In diesem Fall erzwingt der Compiler diese defensive Programmierung zum Glück.

Abschließend noch ein anderes Beispiel:

class Example 
{
    public virtual int GetValue(int input) => Math.Abs(input);
}
//Anwendung analog zu deinem Beispiel mit GetLength.
void int DoSomething()
{
    Example example = GetExample(); //irgendwoher geliefert
    for(int i = 0; i < example.GetValue(j); ++)
        return bedingung ? 0 : 1;
}

So. Stellen wir uns mal kurz vor, der Compiler würde das zulassen nach dem Motto "der Programmierer weiß schon, was er tut".

Und jetzt kommt der Kollege, der für die GetExample()-Methode zuständig ist, auf folgende Idee:

class OtherExample : Example
{
    public override int GetValue(int input) => input;
}

...und dein Code geht den Bach runter. Und deshalb programmiert man für die Signatur einer Methode, nicht für ihre Bedeutung.

LaTino
EDIT: das ist nicht an den Haaren herbeigezogen. Bei uns ist das eine der häufigsten Gründe für fehlschlagende Unit Tests. (Es gibt reichlich Situationen, wo dich der Compiler nicht zwingen kann, defensiv zu programmieren.)

Hängt ein bisschen davon ab, womit du die App erstellen möchtest. Ich bin kein Xamarin-Experte, aber mein erster ANlaufpunkt wäre da zum Beispiel Android.Nfc.NfcManager Class gewesen.

LaTino
(falsches Forum, übrigens)

Es gibt hier doch nur zwei Codepfade, oder nicht? Und beide geben etwas zurück.

Vielleicht solltest du nicht mit dem Compiler über die Anzahl der vorhandenen Codepfade diskutieren, da verlierst du 😉. Kurze Frage: wie lautet der Codepfad für csvText.GetLength(0) == 0 und csv.GetLength(1) == 0?

LaTino

Wie überall gibt es auch hier eine Alternative:1.zu https://regex101.com/r/GUH3IH/2/ gehen 1.mit Hilfe der Erläuterungen (rechts oben) verstehen, was passiert 1.auf "Code Generator" (links mittig) klicken 1.auf C# klicken 1.Code übernehmen und verstehen

Vorteil: du kannst sehr komplexe Suchmuster implementieren.
Nachteil: Regex muss man lernen, und der Einstieg ist nicht einfach. (verlinkte Seite hilft etwas)

LaTino
(EDIT: shame on me, hab Abts Hinweis auf regex übersehen. Aber der Link hilft vielleicht noch etwas mehr.)

Was sind "falsche Eingaben"? Ich kann prinzipiell jede Benutzereingabe nehmen und in die Datenbank schieben.

Das einfachste ist: benutz das Control, das nur die Art Eingaben zulässt. NumericUpDown für Zahlen, DatePicker für Datumsangaben, Textbox für Text, Checkbox für bool.

Dann kannst du dir syntaktische Validierungen zumeist sparen. Um semantische Validierung kommst du nicht herum. Die Anforderung, dass in Spalte "c" von Tabelle "xy" nur Zahlen stehen dürfen, die nach Uhrzeit eines bestimmten Client-Rechners bei Vollmond den Wasserstand in Köln darstellen, wenn dieser auf eine Primzahl endet, musst du nach wie vor von Hand machen, weil das Datenbanken eben nicht abbilden können.

LaTino

Ein Delegate ist schließlich ein Funktionszeiger

Dann hast du das Konzept nicht verstanden. Delegaten sind mitnichten Funktionszeiger. Diese Erklärung wird gern verwendet, um das Konzept Leuten zu erklären, die wissen, was Funktionszeiger sind. Der Grund ist, dass beide Konzepte denselben Zweck erfüllen. Du kannst aber gern mal versuchen, in C++ mit Funktionszeigern multicasting abzubilden. Oder co- und Kontravarianz abbilden beim Zuweisen. Oder beim Verwenden als Methodenparameter.

LaTino

Habt ihr da eine Idee ob das überhaupt möglich ist?

Möglich ist prinzipiell immer alles.
Schau dir mal pdfview4net an.

LaTino

Ich habe den Fehler gerade gefunden, da ich die falsche Methode an den Delegaten übergeben hatte!

Naja, prinzipiell ist an dieser Stelle wirklich Quatsch, einen eigenen Delegaten zu deklarieren.

void UseDelegate(Action performAction)
{
    performAction();
}

UseDelegate(() => Console.WriteLine("hello"));
UseDelegate(() => MessageBox.Show("world"));

Mit anderen Worten: statt delegate void MyDelegate(); gibt es Action, die du einfach initialisieren kannst:

Action example = () => Log("Beispiel");

[Artikel] Delegaten, anonyme Methoden, Lambda-Ausdrücke & Co.

LaTino

Und das war meine eigentliche Frage. Wie ich die Oberfläche so anbinde, das der User keine Eingaben machen kann, die hinterher nicht in die DB passen. Das Problem habe ich doch unabhängig davon wie der Datenbank-Zugriff erfolgt.

Uh. Ich bin ein bisschen fasziniert davon, dass es es so eine Herangehensweise noch gibt; zuletzt habe ich dieses GUI-Entwicklungsparadigma im TeamDeveloper 2000 (aus eben jenem Jahr) von Gupta/Centura gesehen. Und diese Oberflächen waren träge, unflexibel, konnten nur auf einer bestimmten Datenbank laufen (deren Struktur man um Himmels Willen nicht anrühren durfte) und benötigte einen Heidenaufwand, um die Datenbank so vorzubereiten, dass das Programm dann auch lief. Im Wesentlichen war das nichts anderes als MS-Access-Masken für Fortgeschrittene.

Der Punkt ist der: die Datenbank speichert deine Daten. Sie kennt deren Form nicht, sie kennt deren Bedeutung nicht, sie kann auch nicht validieren, ob ein Datensatz gespeichert werden kann (wenn der Typ stimmt). Nichts davon. Und weil sie das nicht wissen kann und auch nicht wissen soll (!!), ist sie auch nicht in der Lage, irgendwem mitzuteilen, wie die Oberfläche auszusehen hat, die "korrekte" Daten erzeugt. Ja, Erstimplementierungen von Oberflächen, wenn man es richtig macht, brauchen etwas Zeit: Validierungen wollen geschrieben werden, eventuell braucht man Controls, und so weiter und so weiter. Allerdings gibt es für beides Schnittstellen, die das Leben leichter machen. Dazu kommt, dass man im Lauf der Zeit eine eigene Bibliothek aus Basisforms, Validierungen und Controls erhält. Unser ERP hat irgendwas im deutlich vierstelligen Bereich an Oberflächen, und eine neue Stammdateneingabe inklusive Validierung zu erstellen, ist eine Sache von 5-10 Minuten.

Du müsstest dafür allerdings deine Komfortzone verlassen und die Art und Weise, wie du bisher Datenbanken und Oberflächen entwickelt hast, hinter dir lassen. Ansonsten gilt, was FZelle gesagt hat.

LaTino

Dir ist schon klar, dass das Beispiel da oben nur 3-5 Zeilen wirklichen Code enthält und der Rest ein paar Deklarationen sind? Anders ausgedrückt: nee, noch einfacher wird's nicht.

LaTino

Dein Code kennt zwar die Namen deiner Textboxes, aber nicht ihre Bedeutung. Genauso kennt er auch die Bedeutung der ausgelesenen INPUT-Elemente nicht - das musst du ihm schon beibringen.

Eine schnelle Möglichkeit dazu:

public class ExampleController : INotifyPropertyChanged
{
    private string _givenName;
    private string _familyName;
    
    public string GivenName 
    {
        get { retzurn _givenName; }
        set 
        {
             _familyName = value;
             OnPropertyChanged(nameof(FamilyName));
        }
    }
    public string FamilyName
    {
        get { retzurn _familyName; }
        set 
        {
             _familyName = value;
             OnPropertyChanged(nameof(FamilyName));
        }
    }

    public void Initialize(IEnumerable<HtmlElement> inputElements)
    {
         GivenName = inputElements[0];
         FamilyName = inputElements[5];
    }
}

public class MyForm:Form
{
    public void InitController(ExampleController controller) 
    {
         textbox1.DataBindings.Add("Text", controller, "GivenName");
         textbox2.DataBindings.Add("Text", controller, "FamilyName");

        HtmlElementCollection elems = webBrowser1.Document.GetElementsByTagName("INPUT");
        controller.Initialize(elems);
    }
}

Durch die Initialize()-Methode ordnest du einzelnen Inputs eine Bedeutung zu und speicherst sie, und durch das Binden an den Controller, der die gespeicherten Werte hält, gibst du den Textboxes eine Bedeutung.

Ist nur eine Schablone, ich würde von copy&paste absehen 😉.

LaTino

Zu dem, was Taipi88 grade sagte, noch ein wenig Lesestoff:

ServiceLocator is an anti-pattern

(Beim refactoring im Hinterkopf behalten)

LaTino

Du hast Karl, Heinz und Peter.

Die schiebst du in die Klasse 6a.
Außerdem schiebst du die drei in die AG "Programmieren".

Jetzt schneidest du Karl aus der 6a die Haare und wunderst dich, dass auch Karl in der AG "Programmieren" kurze Haare hat.

Überraschung!

var backupList = originalList.Select(p => (MyType)p.Clone()).ToList();

Je nach MyType unbedingt prüfen, ob evtl eine deep copy nötig ist.

LaTino

EDIT: dann stehst du natürlich vor der Aufgabe, herauszufinden, ob ein Objekt überhaupt geändert wurde (ob man es Speichern muss, zB). Und weil du nicht der erste bist, der so etwas machen will, gibt es seit >20 Jahren das Command-Entwurfsmuster, das solche umständlichen Transaktionen wie das Kopieren von Objekten elegant umgeht.