Die Köpfe hinter Roslyn bringen nichts in den Compiler, um Deinen Quellcode zu verschlechtern.
Korrekt Anwenden und nachdenken ist immer noch Deine Aufgabe.

Sehe ich auch so. (Auch wenn nicht alles was MS Entwickelt unbedingt sinnvoll ist, die haben auch schon genug Leichen auf dem Buckel).
Im Endeffekt ist es mein/unser Quellcode und ich/wir müssen entscheiden was wir verwenden.

Und um eine Entscheidung zu treffen kann einen eine Diskussion im Forum helfen.
Meine Einwende hab ich ja vorgebracht.

Und ja rapid development (RAD) hab ich jetzt nicht betrachtet. Genau sowenig wie du, wenn du zu der Verwendung einer 3-Layer Architektur Rätst mit der Implementierung von Endsprechenden Schnittstellen (Halte ich im allgemeine für eine gute Lösung). Auch wenn man einfach nur Daten aus der DB an die UI binden will.

Ich muss an dem Punkt aber auch gestehen, dass ich kein großer Fan von RAD Lösungen bin. Meiner Erfahrung nach, kommt man da schon recht schnell an seine Grenzen wenn es etwas kompliziertet wird. Und dann ist es im Enddefekt Teurer, als es direkt vernünftig zu entwickle.
(Erklärt auch mein Gehalt und ich denke mal du wirst auch nicht schlecht bezahlt 😉 )

Bei der Umsetzung, werde ich mich natürlich mit meinen Kollegen zusammen setzten und Besprächen was wir für Sinnvoll halten.
Und bei den Codereviews auch darauf achten, dass es Umgesetzt wird.

Palin, es handelt sich hier im eine >>>>>Syntax-Erweiterung<<<<<.
Niemand zwingt Dich, dass nun alle Deine Quellcodes auf das neue Format migrierst oder "alte Dinge" nicht mehr nutzen darfst.

Ist mir schon klar. Ich arbeite halt im Team und damit ist es nicht mein Quellcode sondern unserer. Und gegen Syntax-Erweiterung hab ich nichts. Ich finde nur es kann nicht schaden bevor man etwas benutzt sich Gedanken drüber zu mache. Vor- und Nachteile abzuschätzen und zu überlegen welche Auswirkungen sich daraus ergeben. Frei nach dem Motto: „Zwei mal Denken, einmal Schreiben“.

Du kannst weiterhin bei den Tuples mit einer Klasse als Rückgabe arbeiten. Aber wie sinnvoll ist so eine Klasse wie Du sie hier als PersonNames bezeichnest, wenn Sie genau ein einziges Mal verwendet wird?

Eine Klasse zu schreiben, die eine Handvoll Male verwendet wird: Zeitverschwendung, zusätzlich zu testender Code! Häufige Nutzung, evtl im Rahmen eines SDKs: völlig legitim und vorzuziehen.

Grundlegend genau so sinnvoll wie ein Interface, was nur von einer Klasse Implementiert wird. (Was bei einer Schichtentrennung mit IService, IRepository u.s.w. doch schon mal vorkommt)
Der Vorteil ist, das ich meiner Software flexibel und änderbar halte. Wenn ich die Tuples in einer Public Methode verwende (oder noch schlimmer zu dem in einem Intreface deklariert habe). Kann sie von jedem verwendet werden. Wenn ich an einer stelle jetzt einen zusätzlichen Rückgabewert mehr brauche, muss ich alle Aufrufe anpassen. (Und bei den Beispiel kann es gut Vorkommen, dass ich noch eine Anrede Brauche) Und genau das möchte doch ich eigentlich Vermeiden.

Software soll möglichst einfach änderbar sein. (Ich hoffe den kannst du zustimmen, wenn wir da andere Grundsätze Vertreten (z.B: möglichst wenig Quellcode). Reden wir nur aneinander Vorbei.

Und für Getter und Setter schreibe ich keine UnitTest. Sondern für Logik und die Steckt meist in den Funktionen. Damit wären wir dann beim nächsten Thema.

Ich finde das sehr gut, denn ich halte meinen Code heute schon modular; muss aber auf teilweise viele private Methoden zurückgreifen, obwohl die Methode nur an einer einzigen Stelle aufgerufen wird.
Damit das wiederum übersichtlich bleibt arbeite ich mit partial Klassen und verschiedenen Dateien.

Das mit dem Modularen kenne ich und ja auch ich hab viele private Methoden. Ich persönlich mag den Ansatz, in der Eigentlichen Methoden, sind dann nur die wesentlichen Schritte zu finden. Und wenn man noch aussagekräftige Namen für die Methoden findet, kann man den Quellcode gut lesen und sich auf das wesentliche Konzentrieren. Wenn einen dann doch die Details Interessieren, kann man auch einfach in die Methode springen. Das mit der partial Klasse mach ich jetzt nicht (meistens sind die Klassen nicht groß genug das es sich lohnen würde) , finde ich aber einen Interessanten Ansatz.

Aber genau das kannst du ja nicht machen machen wenn du Local Functions verwendest. Dann ist die Funktion ein Teil deiner Methode. Und du hast sie alle in einer Datei.

Dann kommt noch hinzu, das auch wenn du sie jetzt nur einmal Brauchst, es in Zukunft dazukommen kann das du sie auch noch in einer anderen Methode brauchst. Das heißt du must die eigentliche Methode anpassen und nach deinem Verlinkten Beispiel auch die Methode selber (Übergabeparameter).

Hinzu kommt ich kann die Methode im Zweifel nicht für sich Testen. (Kann man drüber diskutieren ob es sinnvoll ist, ich persönlich finde es schon ganz angenehm, das wenn eine Methode mal Komplexer werden sollte, ich sie auch alleine Testen kann. Ist sicher Geschmackssache.)

Dein Verlinktes Beispiel finde ich ehrlich auch nicht wirklich gut. Weil er meines Erachtens, die sinnvollste Alternative ausgelassen hat (Auch das Return Statement nach der Methode zu setzten finde ich nicht besonders geschickt, wenn hätte ich es nach dem letzten if gesetzt).

Aus

public static IEnumerable<TResult> SuperZip<T1, T2, T3, TResult>(IEnumerable<T1> first,
    IEnumerable<T2> second,
    IEnumerable<T3> third,
    Func<T1, T2, T3, TResult> Zipper)
{
    if (first == null)
        throw new NullReferenceException("first sequence cannot be null");
    if (second == null)
        throw new NullReferenceException("second sequence cannot be null");
    if (third == null)
        throw new NullReferenceException("third sequence cannot be null");
    if (Zipper == null)
        throw new NullReferenceException("Zipper function cannot be null");

    IEnumerable<TResult>Iterator()
    {
        var e1 = first.GetEnumerator();
        var e2 = second.GetEnumerator();
        var e3 = third.GetEnumerator();
        while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
            yield return Zipper(e1.Current, e2.Current, e3.Current);
    }
    return Iterator();
}

Bekommen wir dann.

public static IEnumerable<TResult> SuperZip<T1, T2, T3, TResult>(IEnumerable<T1> first,
    IEnumerable<T2> second,
    IEnumerable<T3> third,
    Func<T1, T2, T3, TResult> Zipper)
{
    if (first == null)
        throw new NullReferenceException("first sequence cannot be null");
    if (second == null)
        throw new NullReferenceException("second sequence cannot be null");
    if (third == null)
        throw new NullReferenceException("third sequence cannot be null");
    if (Zipper == null)
        throw new NullReferenceException("Zipper function cannot be null");
 
        while (first.MoveNext() && second.MoveNext() && third.MoveNext())
            yield return Zipper(e1.Current, e2.Current, e3.Current); 
}     

Mir gefällt hier die 2. Variante besser.

Es geht bei diesen Erweiterungen nicht darum, dass alles eingespart wird und das Prinzip der Objektorientierten Programmierung untergraben wird.
Es geht hier um Effizienz!

Ja da stimme ich zu es geht um Effizienz.
Und was sind wirklich wichtige Punkte, für die Effizienz.
Gut lesbarer und verständlicher Quellcode. Quellcode wird einfach öfter gelesen als geschrieben.
Die Möglichkeit einfach Änderungen durch zuführen. Software ändert sich mit der Zeit.
Gute Unit Tests. Je später der Fehler gefunden wird, je teurer und schwieriger wird es ihn zu finden. Und bei Änderungen bekomme ich eine Rückmeldung ob noch alles so funktioniert wie es sollte.

Und hier sehe ich die Features, eher als Hindernis an. Man sollte an den Punkt schon genau wissen, was es bedeutet sie zu Benutzen.

Ich stehe den Tuples ein wenig skeptisch gegenüber.

(string first, string middle, string last) LookupName(long id)

im Vergleich zu

PersonNames LookupName(long id)

finde ich schon nicht so schön.

Auch ist die Frage wie es mit Änderungen aussieht.
Mit Wildecards sähe es ja so aus.

var (first, *, *) = LookupName(id1);

Wenn ich jetzt die Methode erweitert will, z.b. um Title.

(string title, string first, string middle, string last) LookupName(long id)

Muss ich ja, wenn ich es richtig sehe, alle aufrufe anpassen. Das finde ich jetzt nicht wirklich schön. Also bei public Methoden werde ich es wohl erst mal nicht verwenden. Bei private Methoden vielleicht, kommt auf die Methode an und ob da eine Klasse nicht besser geeignet ist.

Was die Local functions angeht.

Wenn ich beides Vergleiche.
Das

public int Fibonacci(int x)
{
    if (x < 0) throw new ArgumentException("Less negativity please!", nameof(x));
    return Fib(x).current;

    (int current, int previous) Fib(int i)
    {
        if (i == 0) return (1, 0);
        var (p, pp) = Fib(i - 1);
        return (p + pp, p);
    }
}

und das

public int Fibonacci(int x)
{
    if (x < 0) throw new ArgumentException("Less negativity please!", nameof(x));
    return Fib(x).current;

}

(int current, int previous) Fib(int i)
{
        if (i == 0) return (1, 0);
        var (p, pp) = Fib(i - 1);
        return (p + pp, p);
}

Finde ich ist kein großer unterschied. In der 1. Variante ist die Locale Funktion nicht separat zu testen (muss auch nicht unbedingt) und kann nicht wieder Verwendet werden. Finde ich auch nicht so schon.

Das mit dem Switch statements with Patterns finde ich wirklich gut.

p.s.
Abts Anspielung, das weniger Code besser ist (was ich auch schon in anderer Form so gelesen hab. Fine ich nicht unbedingt.

Hier mal ein Beispiel in Actually([/code]stackoverflow code colfstackoverflow code colf)

S;F@N

Finde ich deutlich schwerer zu Verstehen, als das gleiche in C++ umgesetzt.

void minmax(std::vector<int> v) {
    int min = v[0]; int max = v[0];
    for(std::vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        if (*it < min)
            min = *it;
        if (*it > max)
            max = *it;
    }
    std::cout << min << ' ' << max << std::endl;
}

Wichtig für mich ist unterandern die Wartbarkeit. Und dazu gehört es das der Code gut lesbar und verständlich ist. Was man mit C# doch sehr gut machen kann (Ja es gibt auch Leute die es mit C# hinbekommen nicht lesbaren und verständlichen Code hinzubekommen, das sehe ich aber nicht als Feature von C# 😉 ). Und wenn dann ein paar Zeilen mehr Code sind wehen stört das wirklich.

zu a) Platz sollte wirklich keine Rolle spielen.

zu b) Wenn du nur 1 Exe haben willst schau dir mal ILMerge an.

zu c) Die Exe mal eben auf einen anderen Rechner kopieren und Ausführen geht so nicht. Und lokal die Exe hin und her zu Kopieren machen jetzt die wenigsten.

Ich würde dir auch davon abraten, im Endeffekt macht es mehr Probleme als es Vorteile hat.

Könnte mit Dynamic Objekt und es an ein Grid zubinden funktioniern.

MSDNForum:Bind dynamically created properties to a grid

Hier die Lösung.

Das Skript aus dem Beitrag
Versioning your SQL Server Database using Team Build and Release Management funktioniert bei uns.

Es fehlt nur die Funktion Set-XmlElementsTextValue die ist in diesen Beitrag zu finden.

Powershell functions to get an xml node, and get and set an xml element’s value, even when the element does not already exist

Dann schau mal auf dem SQL Server ob da die Abfrage ausgeführt wird.

Die letzten ausgeführten SQL-Abfragen anzeigen

Ein einfaches Select * from Tabel liefert dir auch keine Daten zurück?

Nun da der Code schon von jemand anderen ausprobiert wurde, scheint er ja grundlegen zu stimmen.

Es kann also nur an den Connection String oder der Abfragen liegen.

Da die Connection keine Excepption wirft, scheint die Verbindung zu einer Datenbank mit den Tabellen zu funktionieren. Hier kannst du mal schauen ob es sich nicht um eine "Kopie" der DB handelt mit anderen Daten.

Wenn du sicher bist, das es sich um die richtige Datenbank handelt.

Beleibt eigentlich nur das Select. Hier kannst du zur Vereinfachung einfach mal das where weg lass und schauen ob dann Daten kommen. Wenn nicht vereinfach mal die Abfrage weiter.

Schau dir mal das an.

MSDN:Erstellen und Debuggen von Office-Add-Ins in Visual Studiohttps://msdn.microsoft.com/de-de/library/office/dn833106.aspx

Wo das Icon angezeigt wird sollte über die Optionen möglich sein:
Zitat:

•Outlook-Add-Ins umfassen Optionen, die Ihr Add-In nicht nur in E-Mail-Nachrichten und Termine einbindet, sondern auch angeben, ob das Add-In zur Verfügung steht, wenn eine E-Mail-Nachricht oder ein Termin verfasst bzw. gelesen wird.

Und welche Icon angezeigt wird sollte ein den Einstellungen (Manifestdatei) einstellbar sein.

Hab jetzt von Office Programmierung keine Ahnung, das ist das was ich bei Google gefunden habe.

p.s. @Moderatoren
Im IE11 hat es grade nicht funktionier, den Text zu markieren, so das er beim hinzufügen des Links übernommen wurde. Auch konnte ich nach dem hinzufügen des Text des Links, die Tab nicht wechseln.

Vereinfacht ist die Collation, die Spracheeinstellung des Server anhand er auch die Tabellen sortiert und die Daten im Passenden Format speichert.

Die kann man einmal für den ganzen Server einstellen, aber auch für einzelne Datenbanken oder Tabellen.

MSDN:Set or Change the Database Collationhttps://msdn.microsoft.com/en-us/library/ms175835.aspx

Hi ohne mir deinen Code genau angesehen zu haben (benutz bitte die Code Taks und Formatiere den Code ordentlich), würde ich jetzt vermuten. Das es an der Collation ("Sprachabhänige Sortierung") liegt. Die kannst du für deine Datenbank setzen. Einfach mal nach Collation googlen.

Grundlegend solltest du aber mit SQL-Parametern arbeiten. Auch hier einfach mal googlen.

Ok, klar 😄
Also müsste ich ja doch immer noch eine Methode implementieren.
Einfach mittels solch einem Container auf "globale Variablen" zugreifen geht somit ja nicht.
Oder denke ich immer noch etwas falsch?

Grundlegen Funktioniert es schon (bei den meisten Containern), sie als „Globale Variablen“ zu missbrauche.
An dem Punkt hast du nichts zu einer Singelton Implementierung gewonnen.

Um mal zu deinen Benutzer zu kommen. Solang du dir sicher sein kannst, das wirklich immer nur eine Benutzer angemeldet ist. Egal wie lange die Aktion (z.B. Bearbeitung von Daten) dauert. Sind beide beide Sachen relative Äquivalent.
Dein Problem wird darin bestehen wenn sich die Benutzer wechseln können, während eine Aktion läuft.

Beide werden es nicht wirklich Befriedigend lösen können. Entweder kannst du nur direkt bei der Aktion Loggen, wenn ein Benutzer sie ausgelöst hat. Oder du musst. Den Benutzer (die Instanz der Klasse) der die Aktion ausgelöst hat weiter durchreichen.

@alta Danke für die Antwort. 👍

Eine Kollege hat mitlerweile an andere Lösung gefunden. (Poste ich hier noch). Dein Werde ich bei gelegenheit mal ausprobieren.

MFG
Palin

Google auc mal nach IoC-Container und Dependency Injection.

Und schau dir in dem Zusammenhang Prism an. Das Frameworke sollst/must du jetzt nicht benutzen. In der Doku von MS sind aber eigendlich allen Pattern enthalten, die du brauchst.

erl = null bring jetzt nichts, du setzt nur die Referenz von erl auf null. HtmlDocument doc hat dann aber noch immer einer Referenz auf das eigentliche Objekt.

Google mal nach "c# webbrowser control memory leak" da findet sich einiges.

Grundlegend kannst du dafür auch einen IOC-Container verwenden.
Je nach dem welchen du Verwendet, kannst du dann einfach entscheiden ob du immer die selbe Instanz haben willst oder dir eine neue Erzeugen lassen wilst.
(Mit google findest du einiges dazu).

Die Idee mit von Th69 mit den UserControlls ist auch nicht schlecht. Du braucht ja nicht immer eine neue Form. Sondern in der Form sollen andere Inhalte angezeigt werden.

Vieleicht ist auch ASP Core, was für dich. Die Ansichte kannst du dann mit HTML erstelln und die Aktualisierungen z.B. mit SignalR machen. Grundlegend kannst du, dann einen WebServer anbieten und die Daten können bei Bedarf auch auf anderen Geräten anzeigen. z.B. Handy.

Nimm doch mal den leeren Catch Block in der CompareTables() Methode weg. Ich denke dann solltest du eine Exception bekommen da "ISH_FALLZAH" nach deiner Angabe in keinen der Tabellen ist. Sondern IST_FALLNUMMER. Und dann auch nur in einer der Tabellen. Genau wie FAL.

Beides mal als ID nehmen und Name weg lassen. Dann sollte Except auch funktionieren.

p.s. Poste bitte nur relevanten Code. Wer hat den schon Lust deinen ganzen Code (teils auch noch Auskommentierten) zu lesen. 😉

Ein IOC-Container ist wirklich Klasse, wenn er von "außen" die Abhängigkeiten auflösen kann.

In z.B. könnte in der Main ein Eintrag wie

IOC.Resolver(this) 

stehen. Und die ganzen Abhängigkeiten in deiner Anwendung würden aufgelöst. Wie du sie Registriert hast, was halt eine Stelle im Quellcode ist. Hast du dann z.B. ein Interface für den Daten zugriff. z.B. IKundenRepository und du stellst in von eine Textdatei auf eine DB. Hast du genau eine Stelle an der du das Ändern musst. Das ist wirklich praktisch.

IUser user = ServiceLocator.Current.GetInstance<IUser>("UserLoggedOn");

Brauchst du da eigentlich selber nie aufrufen.

Der Hacken ist. Das wenn die Abhängigkeiten, nicht komplett vom IOC aufgelöst wurden. Weil vielleicht eine Klasse Irgendwo mit new Erzeugt wurde. Sind weiter Abhänigkeiten nicht aufgelöst. Hier musst du dann Getinstance verwenden (Was dann auch wider die Abhänigkeiten auflöst).
Unschön ist da bei, das du die Abhängigkeiten zum IOC über den Quellcode verbreitest und wenn du den IOC wechseln möchtest. (Hat z.B. einige Funktionen nicht die du brauchst) Musst du alle Stellen im Quellcode anpacken.

Also das eine Klasse, die einen Logge zurück liefern soll. Wissen soll wo hin geloggt werden soll. Hallte ich jetzt nicht für falsch.

Besser als eine Klasse Kunde, die wissen soll wohin geloggt werden sollt.

Du musst auch bei deinem Konstruktor Ansatz mitgeben, wohin geloggt wird. Das muss dann die Aufrufende Klasse wissen oder du löst die Abhängigkeiten über einen IOC-Container auf. Wobei du da zusätzliche Informationen brauchst, wenn du an Verschiedene stellen Loggen willst.

Irgend jemand muss die Entscheidung Treffen. Und genau, das sollte an einer Stelle des Programms passieren und nicht im zweifel über den Quellcode verteilt sein. Was du mit DI machen kannst mit der Factory nicht.

Also über die Factory kann ich Unterschiedliche Logger zurück geben.

Z.B.

ILogger = LoggerFactory.GetLogger("BL");

Könnte mir den Logger für den BL zurückgeben. Deshalb auch eine Factory Klasse.
Unterschiedliche Bereiche in einen Programm kann ich an Unterschiedlichen Orten und in Unterschiedlichen Medien Loggen. Wenn der Bedarf besteht, kann ich auch noch den Sachen aus System.Runtime.CompilerServices einbinden oder per Reflection den Aufrufer bestimmen.

Ich hab genau 1ne Stelle die dafür Verantwortlich ist mir den Passenden Logger zurück zu liefern. Und genau die muss ich anpacken wenn ich was ändern möchte.

Auch wenn Parameter optional sein können, kann ich Sie nicht einfach aus dem Konstruktor Löschen. Wenn du das Loggen aus einer Klasse entfernst und den Konstruktor änderst. Musst du alle Stellen anpassen die den Konstruktor mit den Logger aufrufen. Oder du lässt in drin obwohl er nicht gebraucht wird. Fügst du ihn nachträglich hinzu wird musst du alle Klassen anpassen, die Loggen sollen und ihn Aufrufen (b.z.w. Woanders hin Loggen sollen). Und dann kommt wahrscheinlich noch der Fehler aus aufrufenden Klasse, die keinen Logger übergibt. Und der steht dann an der falschen Stelle (ok kann bei mir auch Passiern, ich kann dann aber einfach meiner Factory anpassen) oder ist gar nicht geloggt.

Auch musst du entweder die Logger komplett durchreichen und jeder muss wissen welchen Logger er weitergibt oder in an den entsprechenden Stellen erstellen.

Ohne IOC-Container ist das die Hölle und wenn du einen Verwendest bist du wider vom IOC-Container Abhängig. Und einfach ein Interface nach ILogger aufzulösen wenn ich mehrere Logger habe, ist auch nicht einfach Möglich. Ich muss als Zusätzliche Informationen mitgeben. Um meinen Konkreten Logger zu bekommen.

Ich sehe immer noch keinen Vorteil von DI zu einer Factory Methode. Eher Nachteile.

Grundlegend brauchst du erst mal einer Eindeutigkeit. Welcher Spalte du mit Welcher Vergleichen willst. Wenn es nicht die ID ist, brauchst du einen Natürliche Eindeutigkeit. Z.B. den Namen.

Darüber kannst du dann einen Join machen und die Felder Vergleichen.

Grob.

Select t1.Name , t1.AnzahlApfel , t2.AnzahlApfel from tabelle1 as t1
join tabelle2 as t2 on (t1.Name == t.2.AndereBezeichnug)
where t1.AnzahlApfel <> t.2AnzahlApfel

@Abt ich hab jetzt deine Frage nicht geanu verstanden.

Ich spekuliere mal. Wenn ich unterschiedliche Instanzen einer Software auf Unterschiedlichene Rechnern. Laufen lassen möchte und diese auf einen anderen Rechner in eine gemeinsamme Datei schreien sollen? Also die Software lauft auf Rechner A und B und beide sollen auf Rechner C in eine gemeinsamem Logdatei schreibe.

Auch da kann auf die Datei nur 1x Schreiben zugegriffen werden. Grundlegend sollte man dann wohl auf dem Rechner C einen Service anbieten. Der über ein Sigelton den zugriff über die Datei Steuert oder einen DB Verwenden.

Wenn dich mir die Instanz des Loggers über eine Factory zurückgeben lasse. Kann ich auch das einfach über die App.config einstellen und muss vielleicht ein paar keinen Änderungen in der Factory Klasse machen. Grundlegen könnte ich auch den Logger bei starten der Anwendung in die Factory injizieren.

Grundlegend ändert sich aber nicht viel an der Aussage. DI ist nicht wirklich geeignet, da die Klasse nach außen noch eine Schnittelle haben muss. Klassen sollten eigentlich nur die Schnittstellen anbieten. Die sie nach ihrer Zuständigkeit brauchen.

Wenn ich z.B. eine Klasse für die Berechnung Romische Zahlen habe, sollte diese einen Integer Wert erwarten. Und nicht zusätzlich noch einen ILogger. Das Loggen ist nicht die Aufgabe der Klasse und sollte somit auch nicht Teil ihrer Schnittellen werden.

Also für mich gehöre, das Logging grade zu den Sachen bei denen DI und/oder eine IOC-Container nicht unbedingt gut geeignet sind.

Erstmal zu DI. Die Klassen (was doch recht viele sind) in denen ich den Logger brauche, müssen dann Entweder ein public Property oder über den Konstruktor, die Möglichkeit bereitstellen, denn Logger zu Injizieren.
Das erweitert die Schnittstelle (nicht Interface) der Klasse.
Ich sage also einen Benutzer meiner Klassen, das ich einen Ilogger brauche, auch wenn es mit der Eigentlichen Aufgabe der Klassen nicht zu tun hat. Was schon mal unschön ist.
Ohne IOC-Container, muss ich dann den Logger, durch alle Klassen durchreichen. Mit IOC-Container bin ich dann vom Container abhängig. Und das alle Abhängigkeiten über ihn Aufgelöst werden.
Sollte die Klasse kein Logging mehr brauchen. Hab ich dann entweder noch die Schnittelle nach außen, die Intern nicht gebraucht wird oder ich muss die Aufrufe anpassen. Ok wenn ich keinen IOC-Container verwende.
Umgekehrt hab ich das gleiche Problem. Wenn ich ein Logging brauche in einer Klasse die kein Logging hatte, muss ich die Schnittstellen anpassen.

Was mich dann zu IOC-Container bring. Wenn er in der Lage ist die Abhängigkeiten von Außen auszulösen. Ziemlich geil macht wirklich Spaß. Wenn nicht, ist es nicht so schön. Dann kann man zwar noch mit dem „ServiceLocator“ arbeiten. Hat dann aber in den Klassen eine Abhängigkeit zu IOC-Container oder lagert es aus in einen Statischen Aufruf aus. (Was Paladin007 ja schon vorgeschlagen hat). Was keinen Vorteil zum SingelTon bzw. einer statischen Faktory Methode hat.

Meines Erachtens sogar Nachteile, da z.B. ich für Unit Test auch immer einen IOC-Container verwenden muss.

(Sind schon ziemlich viele Abhängigkeiten vom IOC-Container, besser man ändert in nie)

Grundlegend zum Logging. Ich möchte meine Informationen, alle in eine Datei schreiben. In Dateien können mehre Aufrufer nicht gleichzeitig schreiben. Also brauch ich eine Instanz der Klasse, die in die Datei schreibt. Genau dafür ist das Singelton Pattern da.
Ja IOC-Container sind auch in der Lage immer die gleiche Instanz einer Klasse zurück zuliefern. Es sollten, dann aber auch Azubis und neue Programmiere wissen. Das sie den IOC-Container nutzen müssen. Und nicht versehentlich eine eigene Instanz der Klasse erzeugen. (Murphys Law).

Wie hab ich es gelöst.
Der/die Logger selber ist eine Singelton Implementierung (Dritt Anbieter Logger, gekapselt hinter meiner Implementierung).
Grundlegend soll nur das (mein) Interface ILogger verwendet werden. (Was sehr Flach ist und ich grundlegend mit jedem Logger unterstützen kann.)
Und den Logger sollte man über die (meine) LoggerFaktory abrufen (Es gibt ein paar Sachen die in andere Dateien gespeichert werden).
Der Logger wird über die Config konfiguriert. (Kein Eintrag kein Logging, ist praktisch bei Unit Test, ich brauch da auch keinen IOC-Container).

Solle sich beim Dritt Anbiete, etwas ändern hab ich genau eine Stelle an der ich was ändern muss. Und im zweifel, kann ich den Logger selber schreiben.

Grundlegen sehr einfach (KISS) und es macht genau was ich brauch.

until you try and read or write to an element that doesn’t exist

Das Element Existiert ja, sonst könnte ich ja auch nicht lesend darauf zugreifen. Das mit der .NET-Klasse ist ein "Workaround" um die Exception zu umgehen.

Mit den .NET-Klassen hab ich es jetzt noch nicht Probiert.

Aktuell hab ich ein Tokenizer PlugIn für den TFS gefunden, was eigentlich genau das machen sollte. Mal schauen ob das Funktioniert.

Ich schließe mich da Abt an. Meines Erachtens ist es ein Designfehler.

Wie soll denn jemand der die Klasse benutzt wissen welchen Konstrukte er benutzen soll/muss ?
Intern wirst du dann auch immer Prüfen müssen welch Werte gesetzt wurden.
Die Klasse hat so einfach keine klare Zuständigkeit.

Wenn du bei Klassen Sachen hast die Ähnlich sind, aber nicht genau das gleiche bietet sich Vererbung an. Gleiches kommt in die Basis Klasse und was anders ist in die Abgeleitete Klasse. Dann weiß jeder der die Klasse instanziert genau was er bekommt und du weißt auch in der Klasse was alles zur Verfügung steht.

Mit '#text"' hat es jetzt auch nicht Funktioniert.

Hier noch mal ein Link von dem ich das eigentliche Vorgehen habe.
Powershell functions to get an xml node, and get and set an xml element’s value, even when the element does not already exist

Mit Value hatte ich es schon probiert. Mit Text Probiere ich es mal Morgen auf der Arbeit.

Danke schon mal für die Antwort.

@abt In der Zeile davor kann ich aber auf die Eigenschaft zugreifen und bekomme auch den Richtigen Wert zurück.

Nun das hier waren grundlegend die ersten Ergebnisse die ich bei Googel zu "Powershell XML Update" gefunden habe. Und der Zugriff so ist je eigentlich recht simpel. Wenn er nur Funktionieren würde 🙁

@Th69 Da geht auch meine Vermutung hin. Mir ist nur nicht klar wie ich es ändern kann, es ist der Wert eines Kontens in einem XML Document. Eigentlich sollte es mit dem Schreiben klappen.

Hallo Zusammen,

ich probiere gerade beim Build Automatisch die Version für eine Dacpac Datei zusetzen.
Das auslesen des Konaten aus der *.sqlproj funktioniert. Das setzen der neuen Versionsnummer nicht.

Jemand eine Ahnung voran es liegen kann.

Hier der Code:

[xml]$fileContent = Get-Content($file)
		Write-Host  $fileContent.DocumentElement
		[string]$oldVersion = $fileContent.Project.PropertyGroup.DacVersion

		[string]$newVersion = $oldVersion -replace $versionPattern , $replacePattern
		
		Write-Host "Pattern $replacePattern"
		Write-Host "Alte Version $oldVersion"
		Write-Host "Neue Version $newVersion"


               Write-Host $fileContent.Project.PropertyGroup.DacVersion
				   $fileContent.Project.PropertyGroup.DacVersion = $newVersion //Hier kommt der Fehler
		Write-Host $fileContent.Project.PropertyGroup.DacVersion
		$fileContent.Save($file)

		Write-Host "$file Version geändert."

Und hier die Ausgabe:

Fehlermeldung:
Pattern $1.$2.$3.2379
Alte Version 1.0.0.1
Neue Version 1.0.0.2379

1.0.0.1

Fehlermeldung:
Die Eigenschaft "DacVersion" wurde für dieses Objekt nicht gefunden. Vergewissern Sie sich, dass die Eigenschaft vorhanden ist und festgelegt werden kann.

In E:\Agent_work\4\s\SetDatabaseVersion.ps1:33 Zeichen:8

$fileContent.Project.PropertyGroup.DacVersion = [string]$newVersion> Fehlermeldung:
+ FullyQualifiedErrorId : PropertyAssignmentException> Fehlermeldung:

1.0.0.1

Bei einen "einfachen" werden in den Ordnern nur die Dlls erstellt die sich geändert habe.
Wenn du aber auf "Neu Erstellen" oder "Bereinigen" gehst, werden die Datein in dem Ordnern gelöscht und neu erstellt. Was dann wieder zu den Fehler führt.

Du hast also einen nicht wirklich Lauffähigen Build. Das solltest du schnell beheben.

Wenn der Build wider Funktioniert, dann kannst du nochmal schauen. Ob der eingangs erwähnte Fehler noch da ist.

Schließe mal Visual Studio und Lösch den bin und obj Ordner in deiner Solution (Durch das Löschen muss VS neu kompilieren, deine Änedrungen sollte damit übernommen worden sein.).

Neu Starten und an der Stelle einen Brake Point setzen und mal mit dem Debugger anschauen was an der Stelle steht.

I Es gibt bestimmte Algorithmen, die alle Objekte beachten müssen.

An der Stelle solltest du zumindest ein Interface oder eine Basis Klasse haben. Damit du deinen Algorithmus anwenden kannst. Von denen sollte dann deine Konkreten Klasse erben.

Mit den Klassen kannst du dann auch Anständig arbeite. In der Oberfläche kannst du dann die Benötigten Felder Anzeige, wie soll sonst ein Kunde wissen was er eingeben muss. Du kannst die Werte Validieren u.s.w.

Also das der Aufwand für Windows Forms bei MVVM höher ist als bei MVC oder MVP sehe ich nicht. Meines Erachtens läuft es grob auf den selben Aufwand hinaus. Aber wenn der Aufwand bei MVVM deutlich höher ist, kannst du es ja sicher belegen.

Das bei WPF der Aufwand geringer ist als bei Windows Forms ist klar.

Auch habe ich nicht einfach eine Kernaussage getroffen, wie "MVVM ist das Beste!!!". Sondern begründet wie so ich es meiner Meinung nach so umsetzten würde (Kompatibilität zu WPF und besserer zu Testen). Zusätzlich habe ich, ja dann noch angegeben, das es nicht den einen Weg gibt, sondern viele. Und dazu noch ein paar Begriffe angegeben, nach denen man mal googeln sollte.

Was meines Erachtens deutlich weitergeht, als was du zu einem Service Tier (Tier nicht Layer) in einigen deiner Beiträge geäußert hast. Ein zusätzlicher Tier bietet durchaus Nachteile, die man auch mal äußern sollte.

p.s.
Sollte das jetzt eine Diskussion werden. Bitte nach meine 1. Beitrag abtrennen.

@Abt ich wollte ja auch nur ein bisschen Wiedersprechen. Um mal die Punkte hervorzuheben.

Bei WinForms kannst du die View am ehesten per MVC entkoppeln, ...

Geht genau so gut mit MVVM. Ich sehe da jetzt keinen Vorteil beim MVC Pattern, eher Nachteile.

Es gibt zwar Anpassungsversuche von MVVM für WinForms, aber das entspricht auch weitestgehendst dem Ansatz von MVC bei WinForms, nur mit anderer Bezeichnung.

MVC und MVVM sind sich zwar sehr Ähnlich, der Grundlegend Unterschied ist aber wer wenn „kennt“. Und wenn ich MVVM mit Windows Forms umsetze, statt mit MVC ändert sich im wesentlichen genau das. Der Controller (VM) kennt nicht mehr die View. Sonder die View das ViewModel (Controller).
„V Förmige“ Abhängigkeiten ändern sich in Lineare.

Ich muss da gfoidl, doch ein wenig wider sprechen.

Erst mal zu den Grundlagen der Pattern.

MVC hat eher V förmige (b.z.w. Umgekehrtes V je nach Darstellung) Abhängigkeiten. Der Controller kennt Model und View und beide kommunizieren mit Events mit dem Controller.

MVVM hat eher eine liniere Abhängigkeit. View kennt ViewModel und das kennt das Model. Nach oben wird mit Events kommuniziert.

Mehr sagen beide Pattern erst mal nicht aus (Hohe Abstraktion).

Sowohl MVC als auch MVVM können beide mit WPF und Windows Forms umgesetzt werden. Der unterschied ist, das WPF direkt für MVVM konzipiert wurde und ich so mit keinem/wenig Codebehinde auskomme. Bei Windows Forms werde ich noch Codebehind brauchen.

Meines Erachtens ist es kein Problem mit Windows Forms MVVM umzusetzen, außer das es im Codebehinde ein wenig mehr Aufwand bedeutet als bei WPF. Zu MVC sehe ich da keinen Nachteil, sondern eher sogar Vorteile. Wenn ich bei einen Windows Forms Projekt MVVM verwende, kann ich in Zukunft einfacher auf WPF umsteigen und meines Erachtens ist MVVM auch leichter mit Unit/Integrationstest zu Testen als MVC.

Zur Umsetzung vom MVVM mit Windows Forms gibt es bei Google viele Beispiel und auch einig „Frameworks“, die muss man sich einfach mal Anschauen.

Vielleicht nach zur Abgrenzung. Weder das MVC noch das MVVM Patter enthalten in ihrer Abstraktion so Sachen, wie Daten Laden/Speichern oder Businss Logik. Hier kommen dann noch meist andere Pattern mit ins Spiel. Das geht dann aber schon eher in Richtung Implementierungsdetails. Und selbst beim MVVM Pattern gibt es, da mehrere sinnvolle Ansätze.

Mir Persönlich gefällt der Ansatz gut, bei dem das Model mehr oder weniger einer reine Datenhaltungsklasse ist (was bei DDD schon wieder ein Antipattern ist, da es dann ein Anemic Domain Model ist) und das VM die BL kennt (z.B. über einen Service) und der BL den DAL.
Ist aber Geschmackssache und kommt natürlich auch auf die Anforderungen an.

Meines Erachtens gibt es nicht einfach den Weg, sondern es führen viele Wege zum Ziel. Und wenn man für sich den Richtigen finden will, muss man sich einfach mal ein paar unterschiedliche Anschauen und dann entscheiden welcher für einen der Richtige ist. Da hilft es wenn man die Grundlagen (über der OOP) verstanden hat. Das würde aber den Rahmen des Beitrag sprengen, deshalb einfach mal ein paar Suchbegriffe (Rechtschreibfehler können enthalten sein und die Liste ist sicher nicht Vollständig).

SOLID-Prinzipien
KISS
DRY
YAGNI
Antipattern
TDD (Test Driven Develobment)
CCD (Clean Code Development)

Nach der Installation von Update3 des TFS funktioniert.

Danke erst mal für die Antwort.

Klappt leider nicht. Da ich bei Web.config-Transformation die Parameter bei der Bereitstellung (Build) kennen muss.
Mit Parametern hab ich es auch schon versucht.
Bei der Installation nimmt er aber die defoult Werte und nicht die Werte vom Server.

Hallo Zusammen,

wenn ich mit WebDeploy ein Update ausliefere würde ich gerne die schon vorhandenen Settings (z.B. ConnectionString) des Servers behalten und die WebConfig nur um Settings ergänzen die Gegebenen falls hinzu gekommen sind.

Gibt es da schon was fertiges oder muss ich mir da selber so eine Art Installer schreiben?

MFG
Palin

Hallo Zusammen,

ich würde gerne beim vNext Build im TFS2015 ein ChangeSet für den Build angeben können.

Bei googel hab ich folgendes gefunden.

VisualStudioUserVoice:Specify Changeset or Label to build from on vNext (TFS 2015) builds

Nach dem Link soll es gar nicht gehen.

Dann hab ich noch den Link gefunden.
stackoverflow:TFS 2015 build definition “Get Version”

Nach dem Link soll es möglich sein ein ChangeSet z.B. mit C8 anzugeben. Das hat bei mir jetzt nicht funktioniert.

Jemand eine Ahnung ob es überhaupt geht und wenn ja wie?

Mal auf Groß/Kleinschreibung geachtet, je nach Collation ist SQL nicht Case Sensetive und x ist gleich X

@LaTino mal den Ball ein bisschen flach Halten. Ich finde es nicht gut, wenn meine Kollegen herabgesetzt werden. Hast du das nötig?

Meine Kollegen sind durch aus in der Lage zwischen Binär- und Dezimalsystem umzurechnen.
Es ergab sich nur die Frage, ob es dafür keine Einfache Möglichkeit gibt.

Ich kannte keine, konnte aber auch nicht Ausließen, das es eine gibt. Bei Google hab ich nichts gefunden, also hab ich einfach mal im Forum nachgefragt. Wenn keine eine einfache Lösung kennt. OK. Nachfragen kann aber nicht schaden.

Ich glaube ich hab dein Posting schon verstanden und das ich BitOperationen auf Integer anwenden kann ist mir auch klar.

Und ja ich kann damit die SQL Abfrage ausführen und bekomme auch das richtige Ergebnis.

Ich konnte mein Problem, vielleicht einfach nicht klar darstellen.

Also die Leute die bei uns die Software für die Maschinen Entwickeln wissen grob welches Bit wo für steht. Nicht aber den Integer wert (Dezimaldarstellung). Sie hätten es jetzt am liebsten, wenn sie einfach eine Abfrage in der Form

SELECT *  FROM tabel WHERE table.bitflag &  0101001 < > 0 
   

machen könnten. Um gezielt Einträge zu finden.

Umgekehrt würden sie sich auch gerne die Letzten x Einträge ausgeben lassen und anhand der Änderung der Bit werte (Binärdarstellung) sehen. Was da passiert ist.

Also die Standard Darstellung von Integer Werten sind Dezimal Zahlen, ich hätte sie aber gerne in der Binär Darstellung.

Schön wäre es gewesen, wenn es einen Datentyp gegeben hätte der dieses Direkt unterstützt. (Select * und man hat die Passende Darstellung) Ich hab da jetzt nicht direkt was gefunden.

Was ich gefunden habe, wäre selbst eine Funktion zu schreiben um die Konvertierung zu machen. Wobei ich dann einen String bekommen würde.

Ich hatte jetzt gehofft, dass es da eine Einfache Möglichkeit gibt.

Denn Code hab ich nur für das Beispiel 3-stellig gemacht. Aktuell ist er 12-stellig und kann gegebenen Falls noch mehr Stellen bekommen.

Mich Interessiert bei dem Beispiel, der 1. und 3. Eintrag, weil sich dort der gleiche Status geändert hat. (Not Aus (Ein/Aus))

Grundlegend ist ein Speichern als Integer jetzt kein Problem, dann bräuchte ich nur eine einfache und performante Methode sie wider in die Binär Darstellung zu bekommen.

Bei der Darstellung in Binär Darstellung, geht es ein bisschen um unserer Maschinen Programmierer. Für sie scheint es einfacher zu Interpretern zu sein. Naja die lesen ja auch Hex Werte und könne damit was anfangen.

verwendetes Datenbanksystem: MS SQL Server

Hallo Zusammen,

ich würde ganz gerne Flags in einer SQL Datenbank verwenden.

Grundlegend sind in der Flag Fehler Status einer Maschine Enthalten. Zb. Könnte 001 "Not Aus" sein und 010 "Kein Material vorhanden". In der Datenbank wird für jede Statusänderung ein Log Eintrag Erzeugt. Grundlegend wäre dann bei der Abfrage interessant, die Änderung genau 1nes Statusbits zu erkennen. Z.B bei den Einträgen 001, 011, 010 wäre der 1. und der 3 interessant.

Zusätzlich wäre es schön die Werte direkt so in der Datenbank speichern zu können oder bei einer Abfrage (z.B. MSSQL Studio) direkt angezeigt zu bekommen.

Jemand eine Idee, wie man das geschickt umsetzen kann.

Also erst mal meine persönliche Meinung zu Dateisicherheit in der Cloud und allgemein.

Daten die keiner bekommen soll, sollte man nicht in die Cloud stellen. (z.B. als Prommie Nacktbilder in der ICloud zu speichern, ist keine gute Idee). Ich persönlich würde noch weiter gehen und sie auch nicht in ein Rechenzentrum oder gar einen Gerät mit Internetanschluss aufbewahren.

Gibt aber auch andere Einstellungen dazu.

Nur Feiglinge benutzen Datensicherungen auf Band: richtige Männer laden ihren wichtigen Kram einfach auf einen FTP und lassen diesen vom Rest der Welt spiegeln.

Welche Daten wirklich wichtig sind und ob eine Cloud Lösung genau so sicher (oder Sicherer) ist wie eine „Ähnlich“, kann man einfach nicht im Detail beantworten. Und ich finde das Abt da im Eingangsbeitrag, auch auf den Richtigen Punkt hingewiesen hat. Frei Zitiert:„Hol dir im Zweifel einen Experten“.

Ich denken aber auch das hinter der Cloud eine Menge Potenzial steckt und man es an vielen Stellen auch einfach mit Vorurteilen zu tun hat. Als „guter“ Entwickler, sollte ich mich da einfach möglichst Vorurteil frei Informieren um nicht zu Aussagen zu kommen wie

Ich habe die Länge und Breite dieses Landes bereist und mit den besten Leuten geredet, und ich kann Ihnen versichern, dass Datenverarbeitung ein Tick ist, welcher dieses Jahr nicht überleben wird.

Das ist grob meine persönliche Meinung zu dem Thema.

An dem Punkt möchte ich Abt auch noch mal danken, dass er sich für uns die mühe gemacht hat einen Beitrag zu dem Thema zu verfassen. Das ist nicht selbstverständlich.

Bei der Gelegenheit würde ich auch gerne noch eine paar Fragen loswerden (ja auch ein um die Diskussion noch andere Aspekte beleuchten zu lassen).

1. Was ändert sich für mich als Entwickler / worauf sollte ich achten? (Nicht bezogen auf das Thema Dateisicherheit)
   Ums grobe Stichpunkte zu liefern. Wie mach ich das mit einem Testsystem für die QS, ich möchte ja möglichst nah ans produktive System.
   Kann ich auch ohne Internetzugang Entwickeln oder brauch ich für gewisse Funktionen auf jeden Fall einen Internetzugang.

2. Wie sieht es mit hoch geladenen Dateien bezüglich Virenschutz und Copyright aus. Ich würde jetzt davon ausgehen, dass sich der Cloudanbieter um den Virenschutz kümmert und ich für das Copyright (z.B. Mustererkennung in MP3s) mich selber kümmern muss oder zusätzliche Dienste bezahlen muss (Wenn ja was gibt es da?) .

3. Kann ich Skalierbarkeit nach oben auch bekommen, wenn ich die Kosten nach oben Deckeln möchte. Als Beispiel ich rechne grob mit 100€ für das Projekt bei „normalen“ , Zugriffszahlen. Sollten sich aber höher Zugriffszahlen ergeben, kann ich aber erst mal nur bis 1000€ gehen, weil mir sonst das Finanzielle Risiko zu groß wird.

Hi der Context Stellt nach Definition von Martin Fowler schon eine Unit Of Work da.
(http://martinfowler.com/eaaCatalog/unitOfWork.html)

Teilweise wird auch das Repository Pattern mit dem Context zusammen als Unit of Work bezeichnet.
MSDN:Implementing the Repository and Unit of Work Patterns
(http://www.asp.net/mvc/overview/older-versions/getting-started-with-ef-5-using-mvc-4/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application)

Ich persönlich finde es besser zwischen Repository und Unit Of Work zu trennen. IRepository ist dann meine Schnittstelle zum DAL die vom BL genutzt wird und dort stelle ich die Methoden bereit die gebraucht werden. Wenn es nur eine Lesender zugriff gebraucht wird, wird halt nur der Bereitgestellt.
Die Implementierung vom Repository arbeitet dann auf der Unit Of Work (bei EF der Context) (DI). Der BL weiß an der Stelle nichts über die Unit Of Work.

Der BL sollte an der stelle auch nur das "POCO" kennen und nicht die Entety und ob jetzt ein Proxy (Entität) zurück kommt oder ein "Poco" Weiß der BL nicht. Soll in auch nicht interessieren ob z.B. eine Adresse beim Kunden schon geladen ist oder erst geladen wird wenn darauf zugegriffen wird.

[Edit] Links gesetzt [/Edit]