In der Richtung (Perlen) kenne ich auch nichts in C#.

Wenn überhaupt umgekehrt. Von 2005 kenne ich Amazon: .NET Gotchas. Ist nicht mehr wirklich aktuell, enthält aber einige Beispiele was mit dem Framework gerne falsch gemacht wurde/wird. Wenn du dann nach googelst findest du auch z.B. bei Stackoverflow was dazu.

Was man sich sicher auch immer mal anschauen kann sind die neuen Features, die mit den Versionen hinzugekommen sind. Z.B. MSDN:New Features in C# 7.0

Allgemein kenne ich das nichts. Ich denke auch das es darin liegt, das das Framework eine Riesige menge an Features bietet. Und das was allgemeines zu machen, echt schwer ist. Was man schon mal häufiger finden, sind Bücher die sich in Unterschiedlicher Tiefe mit eine Technologie im .Net Frameworke auseinander setzen. Für WPF gibt es zb. Bücher die sich erst mal an Beginn er richten und die Grundlagen erklären, dann gibt es deutlich Ausführlicher, die sich eher an Leute Richten die die Grundlagen schon kennen und dann gibt es Bücher die auch wirklich hinter gründe Beleuchten und ins eingemachte gehen.

Wenn du vielleicht genauer sagst was du machen möchtest, kann man da vielleicht besser zu Antworten.

Microsoft zieht erneut Update zurück – diesmal für Windows 10 Version 1803

Hier mal was von Microsoft zu dem Thema.
Spiegel:Microsoft warnt vor staatlicher Totalüberwachung

Er findet da das HostingPanel.Wiki Assembly nicht (lauf Fehlermeldung), mal geschaut ob die Datei da vorhanden ist wo sie sein sollte und du auch den Pfad verwendest?

Hast du vlt. eine Ahnung wie das mit den "index1.cshtml.cs" funtioniert ?
Da scheint es ja so etwas wie ein viewModel zu geben.
Aber wie ich das bebutze und dann noch in die ApplicationDbContext einbinde weiß ich noch nicht.

Da weiß ich jetzt nicht was du damit. Aber ich denke, das hat jetzt nichts mit deinem Problem zu tun oder? Wenn es nichts mit deinem Problem zu tun hat, mache bitte einen eigenen Thread dafür auf. Das gestaltet es übersichtlicher.

Schau mal hier: stackoverflow:Get Types in assembly (error: System.Reflection.ReflectionTypeLoadException)

(Aus dem Link) Lass dir est mal genauer ausgeben was das fehl schlägt.

try {
    // your code
} catch (ReflectionTypeLoadException ex) {
    // now look at ex.LoaderExceptions - this is an Exception[], so:
    foreach(Exception inner in ex.LoaderExceptions) {
        // write details of "inner", in particular inner.Message
    }
}

Und schau mal ob die EF Version in der WebConfig Stimmt.

Das schlimme ist eigentlich nur, dass es nur wenige Institutionen gibt, die soviel Geld und Kapazitäten haben.

Nun ja das wird ja gerade in den Beitrag angesprochen. Das es "relative einfach und günstig" ist.

youtube:Übernehmen Hacker bald die Macht? | Harald Lesch

Fand dich ganz Interessant und ich mag Harald Lesch. Aber ich muss gestehen, ich bin jetzt kein IT Sicherheitsexperte, das ich ein paar der Einschätzungen doch für Übertrieben halte. Bzw. wie es rüber gebracht wurde. Die Angriffe halte ich durch aus für möglich, aber die Darstellung, wie „einfach“ es sein soll komplette Netzwerk Infrastrukturen Lahmzulegen erscheint mir sehr Vereinfacht.

Was haltet ihr da von?

heise:Windows 10: Treiber-Probleme bei Intel halten Oktober-Update auf

Hi Gimmick,

um es vielleicht mal mit einem anderen Ansatz zu erklären.

Die willst 3 Quellcode Branchen hab. (Dev, Main, Release)

Ich gehe jetzt einfach mal davon aus, Dev ist deine Brache in der du Features für die Zukunft Entwickelst. Da sind teils Features, drin die noch nicht Komplett Fertig sind. Oder wo ungewiss ist ob sie in der Form wirklich auf Markt kommen. Da soll dann die QS noch mal drüber schauen. Und man kann es vielleicht einigen Kunden schon mal zeigen oder auf Messen vorführen.

Main könnte deine Branche sein, wo feststeht, das ist der nächste „Main“ Release Stand. Da sind neue Features drin, die Schon Fertig sind. Und sie wurde vielleicht ein paar Test Kunden zu Verfügung gestellt.

Und Release ist die Brache, die (in der letzten Version) zu Kunden ausgeliefert wurde. Da trete noch Fehler auf, die müssen dann Möglichst schnell behoben werden. Um dann natürlich Möglichst schnell zum Kunden zu kommen.

Dann kannst (musst aber nicht) du für alle 3 ein Dev, Test und Release Environment haben. Klingt jetzt erst mal schlimmer als es ist. Es ist größten teils Automatisiert und meist sind es nur Kleinigkeiten die sich ändern wie z.B. die Datenbank (lässt sich gut Automatisieren, du muss zwischen Dev und Test Environment nur eine Variable ändern, damit da Verschiedene Datenbanken verwendet werden. (Ich erkläre es hier einfach mal an Hand der DB, ich denke das ist am leichtesten nach zu vollziehen. Es gibt aber auch noch andere Gründe)

Also erst mal das einfachere. Wie so brauche ich zwischen den Quellcode Branches unterschiedliche Environments. Nun meist haben neue Features, auch den bedarf nach neuen Datenbank Feldern. Oder Brauchen neue Tabellen. (Wie gesagt ich mach es jetzt mal über die DB schiene). Die Dev Branche kann dann nicht mit der DB von Main Funktionieren und Main nicht mehr mit Release.

Das das bisschen Kompliziertere (kein muss). Du (kann bei der Dev Enviorment auch jemand anders sein als du) kannst als Entwickler einfach nicht alles Testen, dafür gibt es ja auch die QS. Du möchtest dann möglichst bei den Daten mit denen du testet, die du als Problematisch ansiehst. Bei der QS sieht es da schon ein bisschen anders aus. Die möchten lieber Daten die näher an Realen System vom Kunden dran sind. Und zum Schluss ist da natürlich der Kunde, der hat reale Daten. Und selbst bei der (Quellcode) Dev Branche, kann es sein das man sich da Daten vom Kunden besorgt. Damit die Kunden auf der Messe das Gefühl haben sie „Arbeiten“ an einem Realem System.

Wie sieht da dein Arbeitsprozess aus. (Ich mach es einfach mal am Beispiel von der Release Branche, bei anderen Branchen kann ein Fehler auch einfache ein Änderungswunsch oder ein neues Feature sein und betrachtet nicht alle möglichen Optionen).

Du gehst hin und Behebst einen Fehler. Der Gemeldet wurde last bei dir die UnitTest laufen. Und Checkst die Änderungen ein, wo bei du den Checkin mit dem Fehler verknüpfst, so das man später sehen kann welcher Fehler damit verbunden ist. Der CI Build mit UnitTest wird gestartet und du bekommst automatisch ein Feedback, das es nicht nur auf deinen Rechner Funktioniert. Sondern auch auf dem „Dev Test System“. Nach dem du „alle“ (können auch nur die dringendsten sein) Fehler behoben haste. Sagst du Bescheid (kann auch Automatisch passieren). Wird ein Build erzeugt, der (dessen Artefakt) Automatisch in die „Dev Envirorment“ geschoben wird. (Hier werden dann teilweise, noch Automatisch Integartionstest und Coded UI Test ausgeführt). Der Verantwortlich (kannst auch du sein) das die Software (das Artefakt), den Qualitätsansprüchen genügt. (Je nach Vorgabe kann man da auch noch ein paar Manuelle Test machen Und gibt dann frei das (Artefakt) es in der „Test Environment“ landet. (Was größtenteils Automatisch passiert). In der QS wiederholt es sich dann mit dem Testen und der Freigabe. (Nur die haben halt ein anderes Environment) und dann geht es weiter mit dem Release.

Für mich ist der Punkt, das ich das Vorgehen durchaus für sinnvoll halte. Und das was bisher möglich ist möglichst Automatisiert wurde.

Ja man muss es einrichten und es ist auch mit einem gewissen Aufwand verbunden. Danach muss man aber meist einfach nur ein paar Variablen ändern.

p.s.
Ja es ist schlampig geschrieben und ich hab nur die Aus meiner Sicht wichtigen Punkte angesprochen.

Mit RDP scheint es noch Probleme zu geben.

Zitat:"Für Anwender, die auf Remote-Desktop-Verbindungen angewiesen sind, heißt es daher zur Zeit noch: Finger weg von Version 1809. Ein Workaround eines Redditors besteht darin, die mstsc.exe aus einer 1803er-Windows-Installation zu verwenden."

heise:Windows 10 Version 1809: Die bisherigen Korrekturen

8o Ist schon ein paar Jahre her, wo ich das das letzte mal gebraucht hab. Hatte jetzt nur noch im Kopf das das 1. Bit für das Vorzeichen ist.

Einfach mal an die Binär Darstellung denken
-1 short = 1000 0000 0000 0001
-1 int = 1000 0000 0000 0000 0000 0000 0000 0001

Ich finde das Lizenssystem vom TFS (zur Vereinfachung) auch ein bisschen unübersichtlich. Aber Grundlegend ist schon richtig was du sagst, Nutzer die das System nur als Informationsquelle brauchen, brauchen keine Liezens. Man kann aber auch ohne CAL zu brauch noch mehr machen. Da solltest du dir aber dann mal genau die Lizenzen anschauen.

Auch ohne Cloud hat der TFS ein Webe Webseite, die im allgemeinen für den zugriff (auf die Informationen) genutzt wird. Es gibt aber auch noch unterschiedliche Tool mit denen man zugreifen kann.

Hi Contace,

einmal kannst du hingehen und sagen es wird eine Zahl (N) angegeben bis zu der du die Werte von 1 in Kreise aufteilen möchtest und dann brauchst du noch die Anzahl der Kreise (K). N/K ergibt dann die Anzahl von Zahlen Pro Kreis (AK), hier brauchst du einen Teiler ohne Rest. Dann Teilst du 360° durch AK und bekommst den Winkel im den du immer wider Verschieben musst. Schau dir mal die Funktion von Mars Stein an)

[Edit]
Für den Nächsten Kreis fängst du dann natürlich ein Stück Höher an zu Zeichnen.

Es ist in dem Rahmen nicht unbedingt der „Ist Zustand“ sondern der „Soll Zustand“.

Aber ich denke wenn man sich die Beiträge/Personen anschaut, die eine hohe Reputation (Bewertung) haben. Geht es nicht nur darum, einfach ein Problem zu lösen, weshalb sich viele Leute an Stackoverflow (Exchange) wenden. Sonden zu erklären was dahinter Steckt. Was teilweise deutlich tiefer geht als Artikel die man auf Wikipedia finden kann.

z.B. Macht meines erachten Eric Lippert da wirklich gute Arbeit.

Ergänzend vielleicht noch.

Wenn ich es richtig im Kopf habe Beschränkt TDD wie es sich Kent Beck vorgestellt hat auf „reine Unit Test“. Integrationstest und Coded UI Tests sind da nicht wirklich vorgesehen. Und wenn der Code nicht Testbar ist, können sie dich auf Fehler bei der Software Architektur aufmerksam machen.

„Reine Unit Test“ sind im allgemeinen sehr sinnvoll, da sie im Endeffekt kosten Sparen. Dazu gibt es auch eine Studie die bei IBM und Microsoft durchgeführt wurden (Bin grade zu faul das Raus zu suchen, sollte sich aber über google finden lassen.). Sie sind relative einfach geschrieben und der nutzen ist relative groß.

Integrationstests und Coded UI Test, sind da schon ein anderer Punkt. Sie sind je nach Gegebenheit relative aufwändig. Und der nutzen ist meist nicht mehr so groß wie bei Unit Tests. Teils Testen sie nochmal was die Unit Test schon abdecken. Hier muss man einfach zwischen Kosten und nutzen Abwiegen.

Das „Driven“ in TDD, kann schon mal bei manchen Programmieren für Probleme sorgen. Da es ihnen schwer Fällt, erst den Test zu Schreiben und dann den eigentlichen Code. Meines Erachtens ist es da auch nicht sinnvoll, die Leute dazu zu Zwingen. Sondern es vollkommen OK, wenn sie erst den Code schreiben und dann die Tests. (Wenn es dann Probleme gibt die Test zu schreiben, müssen sie halt dann ein Refactoring machen.)

Ich denke hier sollte man das Eigentliche Ziel nicht aus den Augen verlieren. Man schreibt Tests, weil sie die Produktivität steigern. Und es deutlich günstiger ist, wenn ich den Fehler bei mir finde, als wenn mir ein Kunde von einem Fehler berichtet und ich dann erst auf seinen System den Fehler nachvollziehen muss.

Was mich eigentlich zu einen Anderen Punkt führt (und vielleicht ein anders Thema sind, im Zweifel bitte abtrennen). Nicht nur Unit Test sind ein Schlagwort, sondern Natürlich auch Agile Software Entwicklung mit Scrum oder Kanaban (Halte ich Persönlich für sehr gut und ich denke man sollte schauen, sie soweit wie Möglich Umsätzen). Was dabei meines Erachtens oft übersehen wird. Ist das man mit Menschen zusammen Arbeitet und es im Unternehmen, existierende Strukturen gibt. Und das eigentliche Ziel es nicht, nicht ist Scrum oder sonst was umzusetzen. Sondern Produktiver zu Arbeiten. Was eigentlich auch Grundlage des Agilen Manifests sind.
Scrum usw. können einen dabei Gute Hilfestellung leisten. Ich denke aber was wichtiger ist Individuell auf die Menschen und das Unternehme einzugehen.

Bin eigentlich noch dabei, eine Ergänzung zu meinen 1. Beitrag zu schreiben und habe eigentlich keine Lust mit Abt zu diskutier. (Ich werde es auch nicht machen.)

Aber Nein ich kann kein Interface mit Unit Tests testen (auch nicht Interface*), sondern nur Konkrete Implementierungen. Ein Interface MakeSound, was für eine Implementierung Katze „Miau“ und für einen Hund „Wuff“ zurück gibt. Kann nicht als Interface getestet werden. Es gibt natürlich Fälle in denen ich die Gleichen Werte in eine Methode gebe und dann die Gleiche Rückgabe erwarte. Grundlegen sollten die Implementierung der Methoden was anders machen. Sonst bräuchte ich nicht die 2. Implementierung, der Methode. Und dann sollte ich sie Unterschiede Testen.

Interfaces sind dann Interessant, wenn ich sie durch Mocks (Ich ersetze die Konkrete Implementierung durch eine Klasse, die mir einen Vorgegebenen Wert zurück gibt) bei Integrationstests ersetze kann. Und so die Tests Vereinfachen kann. Um sie z.B. von einer DB abzukoppeln.

Da sind wir aber eher bei Integrationstests.

Hi Solix0x,

bei TDD schreibst du ja Test für Methoden die Public sind. Du kannst Teile des Codes natürlich auch in private Methoden auslagern. Das sollte in der Refactoring Phase passiert. Vereinfacht. Test schlägt Fehl -> Test bestanden -> Refactoring Test funktioniert immer noch. Nächster Test für die Methode.
Wenn es nötig ist kannst du die private Methode auch beim Refactoring in eine eigene Klasse auslagern und public machen. Deine Tests sollten immer noch Funktionieren und du kannst, dann wenn es nötig ist für die Methode Tests schreiben.

Änderungen sind ja eigentlich im Normalen Workflow schon vorgesehen. Du fängst ja möglich einfach an. Ich denke mal anstelle einer Zahl als String übergibst du "NULL" , "STring.Empty" oder eine andere ungültige Eingabe. Ich würde hier eine Exception erwarten. Dann kommt der nächste Test z.B. "1" ich würde erwarten. Das mir die Methode dann die Zahl zurück gibt. (Negative Test auf Max und Min nicht Vergessen). Und dann die Addition "5+3". Vielleicht brauchst du ja erst mal die Multiplikation nicht und musst sie erst Jahre später Implementieren. Dann schreibst du die neuen Test und implementierst die Änderungen. Die alten Test sollten in dem Fall noch weiter Funktionieren.

Es kann natürlich auch sein, das Änderungen alte Test brechen. Weil es so gewollt ist. Dann spricht nichts dagegen den Test auch zu ändern. Z.B. könnte "*" im String erst mal eine "Not Supported" Exception schmeißen. Was sich dann ändert, wenn es nach Änderungen doch funktionieren soll.

Der Punkt hier ist, das du drauf hingewiesen wird. Das sich was geändert hat und du dann zustimmst, das du die Änderung auch möchtest.

Und ja es wird manchmal als Nachteil Bezeichnet, das wenn man Breaking Changes macht. Noch den Aufwand hat etliche Tests anzupassen. Der Vorteil ist, es kann dir nicht aus Versehen geschehen.

Das eigendliche Buch von Kent Beck zu TDD finde ich persönlich auch nicht zu gut. Ganz nett für die Grundlagen, aber ich denke nicht wirklich für den Alltag brauchbar. Amszon:Effektives Arbeiten mit Legacy Code und Amazon:The Art Of Unit Testing finde ich da schon besser.

Hier noch mal ein aktueller Beitrag zu dem Thema

heise:Microsoft hat versagt: Analyse zum Rückzug von Windows 10 1809 und Server 2019

Coding Horror:What does Stack Overflow want to be when it grows up?

Ich fand seine Gedanke dazu, was es ist ganz interessant.

Hi romanmiller,

poste doch bitte mal die Konkrete Fehlermeldung.
Ansonsten schau mal mit dem Debugger was in "ApiResponseStr" drinsteht. Und prüfe mal ob es mit der Klasse "APIResponse" übereinstimmt.

Am Berliner Bahnhof wurden ja jetzt Test zur Gesichtserkennung durchgeführt.
Hier mal was der CCC davon hält.
Biometrische Videoüberwachung: Der Südkreuz-Versuch war kein Erfolg

Hi Olii,

du solltest vielleicht erst mal schauen ob Caching nötig und sinnvoll ist.

Zum Thema Caching findend man einiges im Internet.

Hier z.B. mal von stackoverflow.
Es gibt da sehr unterschiedliche Strategien.

Falls jemand da Probleme hat.
https://www.heise.de/newsticker/meldung/Verschwundene-Dateien-Microsoft-zieht-Windows-10-Update-vorerst-zurueck-4182651.html

Hi ErfinderDesRades,

wie machst du nicht eine Abstrakte Generische Basis Klasse, die die Methode zum Abrufen der Daten Public anbietet. Und eine Protetec Methode anbietet, die überschrieben werden muss.

Jetzt mal frei und schnell unterschriebenen

abstract Service
{

protected abstract T GetSpezialFoo(ServiceClient client);

public T GetFoo()
{

 // dazu Logging, Localisation, Errorhandling, response-Header-Auswertung - einmal implementiert, und richtig
         using (var myClient = new TService()) {
            IClientChannel chnl = GetChannelFromClient(myClient);
            using (var scope = new OperationContextScope(chnl)) {
               OperationContext.Current.OutgoingMessageProperties["Autentication"] = _AutenticationToken;
               return GetSpezialFoo(myClient); // <-- Hier wird dann die in den Abgeleitetet Klassen Implementierte Methode aufgerufen.
            }
         }
 

}

}

Hi blacktothemoon,

(ist jetzt ein bisschen her und ich hab da jetzt nicht gegoogeld) aber wenn du nur short (-32.766 bis 32.767 sollte grob stimmen) hast du das 1. Bit (ganz links) für das Vorzeichen (0=+ / 1= ).

Bei ushort hast du nur positive Zahlen. Das 1. Bit wird hier für die Zahl verwendet. Das erste Bit stellt also Zahlen > 32.767 das.

Da bin ich mir jetzt nicht sicher aber 1111.1111.1111.1111 ist glaube ich bei short -1 und wird bei ushort als 65535 dargestellt. -2 sollte dann 1111.1111.1111.1110 sein und 65534.

Am besten selber noch mal nachlesen. Ich hoffe ich konnte grob wieder geben worum es geht.

Abt wie so sollte sich jemand die mühe machen dich zu erstehen. Wenn du dir keine Mühe gibst ihn zu Verstehen?

Der Grundsatz begründet sich auf ein paar einfache Grundlagen. KISS, YAGNI und wenn man mochte auf Coding conventions.

Grundlegend sag ich nicht anderes als."Weise einen Nutzen nach, wenn du es kannst ist es OK es zu verwenden. Wenn nicht, lass es sein."

Mir erschließt sich einfach nicht der Sinn, darin etwas komplizierter zu machen als man muss.

Also ich hab das Beispiel aus dem Beitrag (In dem Thread geht es um eine Andere Frage)
jetzt einfach mal

Synchron ausgeführt

duration 1 : 00:00:00.0002001
duration 2 : 00:00:00.0000011
duration 3 : 00:00:00.0000003
duration 4 : 00:00:00.0000007
duration 5 : 00:00:00.0000007
duration 6 : 00:00:00.0000003

und Asynchron.

duration 1 : 00:00:00.0310582
duration 2 : 00:00:00.0001965
duration 3 : 00:00:00.0001148
duration 4 : 00:00:00.0001227
duration 5 : 00:00:00.0000896
duration 6 : 00:00:00.0001184

Der 1. Asynchrone Aufruf dauert länger als alle 6 Synchronen Aufrufe zusammen.
Ich sehe hier absolut keinen Grund es Asynchron auszuführen.

Das hat nicht mit Bockig zu tun. Das sind Zahlen.

Ich hab da einen einfachen Grundsatz, halte dich an Standards und mache es so einfach wie Möglich. (Wenn Auszubildende den Code Verstehen hab ich gute Arbeit geleistet, senkt auch deutlich die Kosten von Software, da der Quellcode von den meisten Gefleht werden kann.)
Und wenn ich es komplizierter machen will, muss ich einfach einen Mehrwert belegen können.

Also wenn die CPU zu 100% ausgelastet ist bringt mir async auch nichts. Ich denke das eine Betrachtung von knappen System Ressourcen für eine Verallgemeinerung, nicht wirklich sinnvoll ist. Wenn es irgendwo einen Flaschenhals gibt muss ich natürlich schauen, das ich ihn bei meiner Programmierung berücksichtige. Aber das ist ein anderes Thema.

Auch wenn async mittlerweile leichter zu Programmieren ist, heißt es nicht das ich es überall Einsätzen soll.

Einmal entsteht durch den Thread wechsle eine Overhead statt. Wenn ich einfach 2 Zahlen addiere ist der Overhead größer als die eigentliche Operation. Grundlegend lohnt es sich also nicht Operationen auszulagern bei dehnen der Overhead größer ist als die eigentliche Operation.

Dann muss ich auch immer drauf achten das keine Raceconditions auftreten. Wenn das Programm noch in eine Datei schreibt. Kann ich keine Änderungen in der Datei speichern. Das muss ich abfangen. Zusätzlich brauch der User da auch ein Feedback wie der aktuelle Stand ist (z.B. Vorschritts anzeige).

Zusätzlich kommt kommt hinzu das async Funktionen meist auch schwerer zu Debuggen sind.

Ich persönlich halten den Ansatz für richtig asyc zu Benutzten wenn ich es muss. Aber nicht einfach weil ich es kann. (KISS, YAGNI).

Und jetzt weiß ich auch nicht. Langsam beschleicht mich das Gefühl, ich habe Etwas Wichtiges bei dem Thema übersehen und mein Ansatz ist komplett falsch.

Der Zentrale Punkt ist, wie es für den Benutzer herüber kommt. Wenn die Datei in 20ms gespeichert ist, brauchst du keine asynchrone Programmieren und solltest sie auch in den meisten Fällen Vermeiden (Es ist einfacher zu Programmieren).
Wenn das Speichern einer Datei 1 Minute dauert sollte man den Benutzer anzeigen, das was geschieht (Was komplizierter ist).

Ich finde gerade den Artikel nicht. Aber wenn ich es richtig im Kopf habe.

Werden Vorgänge < 100ms als "relative" flüssig Endfunden.
Von 100ms bis 200ms als "stockend".
Über 200ms als Hakend. (Es kommt da auch immer auf die Aktion an, wenn ich eine Maus bewege, möchte ich das sie sich direkt bewegt. Speicher ich eine Datei ist es Ok kurz zu warten.)

Das nur die Telekom zugriff auf die Daten hat, war wenn ich es richtig im Kopf habe, ein Argument wie so Microsoft die Daten nicht ausgeben kann. (Siehe oben).

Und wenn ich das dann auch noch zusammen bekomme. Hatte Microsoft wegen der Verhandlung in den USA überlegt in den Ländern wirklich eigenständige Unternehmen zu Gründen (was dann aktuell wohl nicht so ist). So das die Unternehmen der Lokalen Rechtsprechung unterworfen sind.

(Hab ich aber auf die schnelle auf google nichts gefunden und aus dem Kopf geantwortet).

Hi Fut320,

eine pauschale Antwort gibt es nicht darauf.

Grundlegend ist es wichtig, das der Code gut verständlich ist. Meist ist es dabei Sinnvoll die Objekte da zu erzeugen, wo sie auch gebraucht werden.

Ein anderer Punkt ist die Erweiterbarkeit. Da kann Dependency Injection mit einem IoC Container sehr nützlich sein. Statt also deine Klasse für die Antwort direkt zu erzeugen, könntest du eine IList<IAntwort> rein geben. Die dann z.B. die Methoden IsAntwort und GetAntwort haben. Da kannst du in einer Schleife drüber laufen und feststellen welche Antwort gesendet werden kann und die dann senden. Dann brauchst du immer nur eine passende Klasse anlegen. (Wenn du grade Programmieren lernst ist das vielleicht ein bisschen komplex).

Was wichtig ist kümmer dich erst mal nicht so um Performance und Speicherverbrauch. Sondern schau das du Code schreibst der gut verständlich ist. Und Wartbar.

Aus dem Heise Artikel, den ich oben Verlinkt habe:

"Darin wird festgelegt, dass Dienstebetreiber Kundendaten herausgeben müssen, egal wo die Daten physisch gespeichert sind.

Der Betreiber kann, wenn er möchte, Widerspruch einlegen, sofern die Herausgabe der Daten gegen das Recht jenes Landes widerspricht, in dem die Daten gespeichert sind. Allerdings gilt das nur, wenn der betroffene Kunde weder US-Bürger noch Einwohner der USA noch ein dort registriertes Unternehmen ist. Handelt es sich beispielsweise um einen US-Bürger, zwingt der CLOUD Act den Betreiber gegebenenfalls, ausländisches Recht zu brechen.

Selbst wenn der Betreiber zulässig Einspruch erhebt, müssen die dann zuständigen US-Gerichte so viele Faktoren berücksichtigen, dass eine Aufhebung oder Einschränkung des Herausgabebefehls die große Ausnahme bleiben dürfte.

....

Zusätzlich sieht der CLOUD Act vor, dass der US-Präsident mit anderen Regierungen den gegenseitigen Datenzugriff vereinbaren kann.

...

Betroffene können nicht gegen den Eingriff vor Gericht gehen und müssen auch nicht mehr verständigt werden. "

Ich finde den Satz ja interessanter.

"Wichtiger aber: Spätestens seit dem jüngst verabschiedeten CLOUD Act dürfen US-Behörden auch auf die Server amerikanischer Firmen zugreifen, die im Ausland stehen. Dazu dürften solche mit IP-Adressen, die Microsoft USA gehören, zweifellos zählen."

Wenn Microsoft jetzt wider selber Zugang zu den Servern hat, können die US-Behörden sie dazu zwingen dort gespeicherte Daten herauszugeben.

Probier mal "1([abc]+|[def]+|[ghi]+)2"

Hi n4s,

keiner hier kennt deine Arbeit und kann dir Sagen was da fehlt. Hinzu kommt, das die Unis da auch immer wider andere Ansprüche haben was den Inhalt und Vorm angeht. Du wirst da wohl auch nicht herumkommen Nachzufragen. Ist auch nicht schlimm im allgemeinen Helfen da die Leute gerne.

Grundlegend sollst du ja einen Praktikumsbericht schreiben. Ich kenne es so, das das Thema, darum gehen soll, was du im Praktikum gemacht hast (wenn du sagst was du gemacht hast kann man vielleicht noch ein paar genauere Tips geben) und dabei zu Zeigen das du Wissenschaftlich/Systematisch vorgegangen bist. Dort müssen auch nicht alle Bereiche abgearbeitet werden. Sondern nur was auch wirklich für das Praktikum relevant ist. Klassiker ist da erst mal, den Ist-Zustand zu erfassen. Dann denn Soll-Zustand am besten mit Begründung (Was Bringt das, mehr Wert für den Kunden (neues Feature) oder Vereinfachung für ein (Refaktoring) usw). Dann zeigen was du gemacht hast und wie um zu deiner Lösung zu kommen. Vielleicht mit vergleichen z.B. um den Soll-Zustand zu erreichen gab es Folgende möglichkeiten. A, B und C, nach den Kriteren so und so, konnte ich evaluieren, das der Ansatz A, die in dem Kontext geeignete Lösung ist. Dann vielleicht noch A Ausführlich vorstellen. Dann noch ein Verglich mit deinem Ergebnis mit dem Soll-Zustand. Eine kritische Betrachtung wie es gelaufen ist kann meist auch nicht schaden. Wenn vorliegen, vielleicht noch aktuelle Daten vom Kunden oder so. Und was man auch noch machen kann ein Ausblick was man noch verbessern kann.

Das Argument für die Deutschland Cloud, war doch das die Telekom als Treuhänder fungiert. Und Microsoft so nicht in den USA zur Daten Herausgabe gezwungen werden kann, weil sie gar keinen zugriff auf die Daten haben.

Wenn ich das Richtig verstehen, fällt das ja weg.

Dein Getter schmeißt eine Nullreferenz Exeption wenn myVar null ist (myVar.toString()).

Hi ich bin da jetzt kein Experte,

.Net Core läuft nicht auf XP und dem entsprechend nicht auf XP Embedded.

Grundlegend sollte es aber auf anderen Embedded Systemen laufen. Ich denke mal am meisten kannst du Windows 10 finden. Aber da solltest du mal nach "Windows IOT" googlen.

Hi hat jetzt leider was länger gedauert.

Ich hab jetzt beides ausprobiert und es hat auch keine anderen Ergebnisse geliefert.

Vielleicht noch jemand eine andere Idee?

@LaTino

Mir geht es ja grade darum, das nicht einfach was Auswendig gelernt wird. Sondern verstanden wird was man da macht. Wenn du Mathe Studiert hast, denke wirst du Verstehen, das es ohne das Grundlagen wie Einklammern /Ausklammern und Bruchrechnung nicht geht. Ich kann einen Schüler, dann z.B. noch die PQ-Formel auswendig lernen lassen und ihn sagen wo er was Einsätzen soll. Wenn dann später Integral- und Differenzialrechnung dazu kommt funktioniert es einfach nicht mehr. Das ist halt ein Punkt der mir bei der Nachhilfe oft aufgefallen ist, solche grundlegenden Sachen saßen nicht bei den Schülern und dann wir Mathe echt schwer. Und die Schüler waren nicht zu dumm, es hat sich nur nie jemand mal Zeit genommen es ihnen zu erklären (OK wahrscheinlich haben sie im Unterricht nicht aufgepasst, als es erklärt wurde und es hat dann keinen Lehrer mehr interessiert, das sie es nicht konnte.)

Was die Array angeht. Wie gesagt kann man drüber streiten. Ist es jetzt eine Grundlage?
Nun ich hab es so kennen gelernt. Und es gibt immer wieder Methoden, die ein Array als Rückgabewert haben. Ich denken jeder der eine Ausbildung als Fachinformatiker oder ein Studium abgeschlossen hat. Sollte mit Arrays umgehen können. Ich kenne jetzt keinen der als Programmierer Arbeitet, der es nicht kann. (Ok ich kenne jemanden, der eine Ausbildung als Fachinformatiker gemacht hatte und gar nicht fürs Programmieren über hatte. Der hat sich seine Abschlussarbeit, vom Auszubildenden im ersten Lehrjahr Programmiere lassen. Ich hoffe aber mal, dass das die Ausnahme ist.)

Es geht mir auch nicht darum, einen Anfänger dazu zu zwingen, alles mit Arrays zu lösen.
Sondern eher darum ob es nicht vielleicht sinnvoll ist, ihn erst mal die Frage zu beantworten, die er zu den Arrays hat und ihn dann noch einen Anderen Weg aufzuzeigen. Anstatt um es vereinfacht wider zu geben zu sagen: „Arrays sind doof benutze Listen“.

In der Mathematik geht es nicht um Beweise und Algorithmen, sondern um eine bestimmte Art, zu denken.

Den Satz finde ich sehr gut. Ich finde das gleiche gilt für die Informatik.
In dem Rahmen finde ich, kann es nicht funktionieren, jemanden einfach zu sagen er soll Schema F verwenden. Weil es einfach die Beste Lösung ist.

(Ich denke grundlegenden wollen wir da schon irgendwie das gleiche. Nur reden wir da irgendwo aneinander Vorbei.)

Danke schon mal für die Antworten.
Ich werde es morgen mal ausprobieren.

Hallo Zusammen,

aktuell haben wir eine alte Software in VB6, die eine C++ Schnittelle verwendet und auf Windows XP läuft. Die an eine Maschine einen Befehl per UDP Sendet und per UDP eine Antwort bekommt.

Das soll auf einen WebService umgesetzt werden, der auf einen Windows 2012 Rechener im IIS läuft.

Der WebService sendet die gleichen Daten an, die Maschine. Hab ich mir mit WireShark angeschaut. Aber in WireShark ist keine Antwort zu sehen. (Bei XP kann ich sieh sehen).
In den Log Einträgen, der Maschine ist auch nicht zu sehen, das der UDP Empfangen wurde (bei XP schon).

Firewall ist ausgeschaltet.
Es ist noch ein Router dazwischen, der UDP Broadcasts blockt. Aber Nachricht und Antwort sind Unicasts.

Hat jemand eine Idee, woran es liegen könnte oder was man mal ausprobieren könnte.

Resultat und Ausgabe gibst du ja nicht mit zurück. Sondern nur die Differenz. Aber wenn die kleiner 0 ist hast du dein Tageslimit überschritten. Oder brauchst du jetzt wirklich Hilfe wie man eine if Abfrage schreibt?

Ich hab ehrlich gesagt nicht genau verstanden was, du machen möchtes.

Also in ein (SQL) DB ist der Eintrag für beide Weg wenn du ihn in der zwischen Tabelle löschst.

Objekt Orientiert können sich beide Klassen die gleiche Liste Teilen. Dann wird der Eintrag aus beiden gelöscht. Du kannst aber auch eine übergeordnete Klasse (Bank) machen welche die Verwaltung übernimmt.

(Es ist besser wenn man nicht Versucht DB Konzepte auf die OOP zu übertragen)

Von der Buchhaltung her (wenn ich es richtig im Kopf habe) darfst du den Eintrag gar nicht Löschen sondern musst eine Stornierung buchen. Also gleicher Betrag in anderer Richtung.

Erklär vielleicht mal was du machen möchtest. Und nicht wie du es Programmieren würdest.

Jein.

Ich denke mal mit eine DI Frameworke, meinst du einen IOC-Container. Und ich denke du meinst das richtige. Nur drückst es ein wenig unglücklich aus. Grundlegend kann man einen IOC-Container irgendwo in der Anwendung verwenden und "sagen" gibt mir mal eine Instand von X. Ist aber nicht wirklich schön.

Wenn du es richtig machst, verwendest du ihn nur einmal beim Start (z.B. Apolication Run) und er löst dir alle Abhängigkeiten der Anwendung auf (IView, IBL und IDAL usw. um es vereinfacht dazustelle). Je nach verwendeten IOC-Container, kannst du auch definieren wie die Abhängigkeiten aufgelöst werden. Z.B. wenn du deine Software um ein "Modul" erweitern willst. Reicht es teils einfach eine DLL mit passender Schnittstelle in dein Anwendungsverzeichnis zu packen und das Modul ist verfügbar.
Oder er regelt ob du immer die selbe Instanz einen Objektes (Singelton) oder immer eine neu zurück bekommst. Ein guter IOC-Conatiner kann, da echt eine Menge.

Grundlegend also eher ein bisschen von außen Betrachtet, du rufst nicht die Instanz vom IOC ab (Gut beim Start machst du es). Er löst sie für die auf.

Schau mal mit dem SQL Managment Studio unter Sicherheit\Anmeldungen dein Benutzer\Eigenschaftzen und da unter Benutzer Zuordnung nach dem Standardschema der Datenbank.

Genau nur das wir für die Implementierung des Zugriff auf Ini, Access und SQL eigen Assemblys haben. Haben die Klassen auch ein eigenes Assembly. Man kann sie wenn man möchte noch den DAL zurechnen oder sagen es ist ein eigener Layer.

Im BL machen wir das Mappen auf BL-Objekte nur wenn wir es brauchen. Wir haben viele einfache CRUD Ansichten. Da ist in den einzelnen Schichten zu Mappen nicht unbedingt nötig.