@Palladin. Ja, das gabs damals noch nicht. 😁 und selbst wenn, dann hätten womöglich die meisten das noch nicht gekannt.
Witzigerweise habe ich genau heute den _DispatchProxy _das erste mal ausprobiert. 😁
Bisher finde ich da meine Klasse noch handlicher, ABER wenn das schon .NET jetzt im Gepäck hat und es funktioniert, way to go. 🙂

Zusatztipp an den TE, wenn Du dann tatsächlich XUnit benutzen möchtest, dann:

Kannst Du auch gleichzeitig das hier mitbenutzen und Dir eine Menge Arbeit sparen:

    [AttributeUsage(AttributeTargets.Method)]
    public sealed class AutoMoqDataXUnitAttribute : AutoDataAttribute
    {
        public AutoMoqDataXUnitAttribute()
            : base(() => new Fixture().Customize(new AutoMoqCustomization()))
        {
        }
    }

P.S.: Funktioniert genauso mit NUnit, wenn man die entsprechenden NuGet Packages benutzt.

        [Theory, AutoMoqDataXUnit]
        public void TestHelpAction(HelpAction action)
        {
              [...] //here goes your Code
        }

Damit werden dann Deine Objekte automatisch initialisert und Du kannst sie dennoch kontrollieren, falls nötig und hast dann auch gleich AutoMoq und AutoFixture drin.
Denke das sollte noch zusätzlich helfen.

Was mich interessiert:

Wer von euch benutzt eigentlich in einer Firma

1.) Fuzzing

oder auch

2.) WinDbg Preview (vor allem auch mit TTD - Time Travel Debugging)?

Und was sind eure Erfahrungen damit?

Denn interessanterweise benutzt das soweit kein einziger Entwickler in keinen von den Firmen, wo ich die Leute bisher darauf angesprochen hatte.
Also beides nicht.

Falls es jemanden interessiert:

Was gut funktioniert ist das hier:

https://www.nuget.org/packages/WinSharpFuzz/

Es bringt doch so einiges der Funktionalität von AFL-Fuzz (google/AFL: american fuzzy lop - a security-oriented fuzzer) nach .net.

Wichtig ist, die entsprechenden Projekte in die Solution einzufügen (normalerweise 2), also quasi Main und den vom Main aufzurufenden Code.
Dann muss das ganze noch "instrumentiert" werden, wie sich das nennt.

und "schon" könnt ihr Fuzzing in .NET benutzen.

P.S.: Wenn ihr das noch genauer wissen wollt, kann ich das gerne hier zusammentragen, zum Nachmachen.

Erste Schritte damals:

Wollte unbedingt programmieren lernen, als ich 11 war. Hatte dann aber erst mit 13 die Gelegenheit dazu mir einen eigenen Rechner zu kaufen.
Die beiden Jahre zwischendrin gingen dafür drauf mir mit Taschengeldarbeit das nötige Kleingeld zu verdienen.

Erster Tag, nachdem ich wusste wie man die Console aufmachte (wusste aber noch nicht, dass das eine Console war. 😉:

Abtippen eines Listings aus einem Amiga-Magazin. Jede Zeile wurde schon mit:

"Unknown command"

quittiert.

Als ich - meiner Meinung nach - alles abgetiptt hatte, fragte ich mich:

So. Wo ist jetzt mein Programm? Und wenn ich es gefunden habe, wie starte ich es dann?

😂

Bis mir dann jemand ein paar Dinge erklärt hatte. Dass man einen Texteditor braucht, um Texte abzuspeichern.
Und eine Programmierumgebung. Er hat mir dann erklärt, dass man Programme z.B. mit einem Assembler machen kann.
Und die Programmiersprache nannt er dann ebenfalls so, was bei mir ne ganze Zeit lang zu Verwirrung geführt hatte. 😁

Mein erstes Projekt war damals eine Kugel aus 5000 Punkten auf einem Amiga 500 ruckelfrei zum über den Bildschirm hüpfen zu bringen.
Inspiriert durch die Demo-Szene.

Das hatte 2 oder 3 Wochen gedauert.

Ich hatte keine Ahnung, welche Programmiersprache am geeignetsten ist und bin damals über das Amiga-Magazin in eine Sprache gestolpert.
Natürlich die einfachste, mit der sich so was machen lässt: Assembler.

😂

Später hatte das dann zur Folge, dass meine Basic-Programme (hatte Quick Basic oder wie das damals hiess, dann C++ danach gelernt)
voll von Peeks und Pokes waren.

Interessant dabei: Der Amiga läuft jetzt noch...

Jetzt wollen alle Dein Soundcloud Profile 😉

Haha. Bring mich nicht in Verlegenheit. 😁
P.S.: Oder soll ich das jetzt etwa wirklich hier reinstellen? LOL

Ich hatte damals geschrieben:

wenn ich alleine bin gerne techno, ansonsten alles, quer beet.

find so sachen wie enya auch genial oder evanescence

Was ich damals nicht erwähnt hatte:

Dass ich natürlich auch meine eigenen Kompositionen sehr gerne anhöre.
Das sind hauptsächlich:

• Filmmusik
• Reggaeton
• Pianostücke

aber auch

• Trance/Techno usw.

Sehe ich genauso wie Fzelle und Abt.

Einziger Unterschied:

Falls Dir Open XML zu kompliziert werden sollte,
es kann alles, kann aber auch ziemlich komplex werden.

Dann kannst Du auch Closed XML (nicht Microsoft) verwenden.
Das ist IMHO viel einfacher zu benutzen, falls das, was Du oben beschreibst, alles ist was Du machen möchtest.

Inzwischen habe ich noch eine weitaus bessere (Roh-)Lösung gefunden:

namespace MergeExcels
{
    public class ClosedXmlExcelMerger
    {
        public void Merge(string fileNameSource, string fileNameDest, string workSheetName = "MasterTabelle", string languageToMergeFrom = "es-MX", bool returnNewMergedFile = true)
        {
            IXLWorkbook workBookSource = new XLWorkbook(fileNameSource);
            IXLWorkbook workBookDest = new XLWorkbook(fileNameDest);

            var worksheetSource = workBookSource.Worksheet(workSheetName);
            var worksheetDest = workBookDest.Worksheet(workSheetName);

            //find spanish column in source and dest
            IXLRow firstUsedRowSource = worksheetSource.FirstRowUsed();
            IXLRow firstUsedRowDest = worksheetDest.FirstRowUsed();

            int languageColumnNumberSource = XLHelper.GetColumnNumberFromAddress(firstUsedRowSource.GetLanguageCell(languageToMergeFrom).Address.ToString()); //subtract 1 to be able to use zero based index
            int languageColumnNumberDest = XLHelper.GetColumnNumberFromAddress(firstUsedRowDest.GetLanguageCell(languageToMergeFrom).Address.ToString());

            //Gets all the tokens from Dest
            IXLCells foundCellsContainingValidTokensInDest = worksheetDest.CellsUsed(x => Regex.Match(x.GetString(), Helpers.Helpers.ValidTokensPattern).Success); //IXLCells foundCellsContainingValue = worksheetSource.CellsUsed(x => x.GetString() == value.ToString());

            int cellProcessedIndex = 0;
            foreach (IXLCell cell in foundCellsContainingValidTokensInDest)
            {
                string tokenToFind = cell.GetString().Trim();
                IXLCells foundCorrespondingValidTokenInSource = worksheetSource.CellsUsed(x => x.GetString() == tokenToFind); //IXLCells foundCellsContainingValue = worksheetSource.CellsUsed(x => x.GetString() == value.ToString());

                IXLCell tokenCellInDest = cell;
                string tokenTextFromDest = tokenCellInDest.CellRight(languageColumnNumberDest - 1).GetString();
                if (tokenCellInDest == null)
                {
                    new Exception("This should not happen!");
                }

                //Get the cell to insert to
                IXLCell cellToInsertValueTo = foundCorrespondingValidTokenInSource.First().CellRight(languageColumnNumberSource - 1);
                cellToInsertValueTo.Value = tokenTextFromDest;

                cellProcessedIndex++;               
            }
        }
    }
}

Das hier reicht aus, um den gefundenen Token String (der sich in Helpers.Helpers.ValidTokensPattern befindet) als key zu benutzen für die Zeile und damit von der einen Datei,
die Texte die in der Language Spalte sind in die andere Datei zu übertragen.

Also:

Ich habe eine Lösung gefunden:

Mit ClosedXML geht das ganze sehr einfach.

Damit schrumpft das Alles auf etwas in dieser Art:

            XLWorkbook workBookSource = new XLWorkbook(fileNameSource);
            XLWorkbook workBookDest = new XLWorkbook(fileNameDest);

            var worksheetMastertable = workBookSource.Worksheet("Mastertabelle");

           //find spanish column
            foreach(IXLRow row in worksheetMastertable .RowsUsed())
            {
                string rowText = string.Empty;

                string token = "";
                string languageIndex = "es-MX";
                string tokenText = FindTextForToken(languageIndex, token);

                if (TokenExists(worksheetMastertable , token))
                {
                    AddTokenTo(workBookSource, token);
                }

                foreach (IXLCell cell in row.Cells())
                {
                    var value = cell.Value;
                    rowText += value+" | ";
                }
            }
         
        }

Die Methoden oben, die nicht im Code zu sehen sind, sind bisher leere Pseudomethoden,
die Objekte sind aber sehr leicht im Debugger zu brauchen.
Deswegen sollte das keinen Aufwand mehr brauchen.

Auf Wunsch kann ich auch das fertige Ergebnis später - mit den Methoden - hier posten.

P.S.: Zuerst hatte ich das Ganze mit OpenXML von Microsoft versucht. Es funktioniert zwar.
Ist aber ziemlich aufwändig das Ganze damit zu machen.
Auch wenn man Zugriff auf jedes Atom von Excel hat.

Hatte gemerkt, das braucht doch einiges an Aufwand und Lernaufwand.
Auch wenn ich in 2/3 Stunden was ansatzweise brauchbares hatte.

Hallo Th69.

Es ist das neue Format, also: .xlsx.
Ok, dann werde ich das iterativ bzw. mit einem kleinen Programm machen.
Danke für Deine Hinweise.

Zum P.S.:

Ja, das ist mir natürlich auch bekannt.
Hab auch das Problem gefunden. Im Texteditor war eingestellt: Leerzeichen in Tabs konvertieren.
LOL. Da kann ich natürlich lange suchen.

Denn genau Deinen Ansatz hatte ich ebenfalls verwendet.

Hallo zusammen.

Weiss jemand von euch zufällig, wie man 2 Excel Tabellen, wie unten beschrieben mergen kann?
Auf jeden Fall, diese Art, wie ich sie brauche habe ich bisher nicht sinnvoll in Google finden können.

Grund:

Wir haben hier verschiedene Sprachen mit Items in Excel Tabellen.

Es wurde aber eine falsche Excel-Datei (ältere Version) übergeben, bei der die Spalten nicht mehr übereinstimmen.

Es gilt also folgendes zum vorherigen Stand (Stand 1):

Token Name Deutsch Englisch Spanisch
T.Change Ändern Change
T.Help Hilfe Help
T.New Neu New

Und in einem weiteren Stand (Stand 2), Z.b. das:

Token Name Deutsch Englisch Spanisch
T.Change Ändern Change Cambiar
T.Help Hilfe Help Ayuday
T.Rot Rot Red Rojo

Ich muss also folgendes erreichen, dass Stand 1 und 2 so gemergt werden, dass ALLE tokens von vorhin enthalten sind am Ende:
Und dabei ist also die Token Name Spalte die wichtige. D.h. wenn ein neues Token gefunden wird in Stand 2, wird es in Stand 1 hinzugefügt.
Doppelte Tokens sollten nicht vorkommen, den Fall brauchen wir nicht berüchsichtigen.

Es reicht also z.B. wenn die Spalten auch so generiert werden würden, dass ich sie per Paste einfügen kann.
Anders ausgedrückt: Am Ende soll Stand 1 alle Tokens zusätzlich enthalten, die fehlen, aber in Stand 2 schon enthalten sind.

Weiss jemand, wie ich das erreiche? Mir ist es egal, ob ich dafür ein kleines Programm schreiben muss,
idealerweise in diesem Fall ohne Programmierung. Vielleicht geht das ja mit Excel ganz einfach?

Das wäre dann jedenfalls das gewünschte Ergebnis in Stand 1:

Token Name Deutsch Englisch Spanisch

T.Change ändern Change Cambiar
T.Help Hilfe Help Ayuda
T.New Neu New Nuevo
T.Rot Rot Red Rojo

P.S.: In der Vorschau im Editmodus wird die Formatierung bei mir richtig angezeigt der Tabellen.
Leider ist die Formatierung nicht richtig, wenn man sie im fertigen Beitrag anschaut, bisher weiss ich nicht, wie sich das ändern liesse, ohne einen Screenshot zu erstellen.

@Abt.

Wie ich ja gesagt hatte, ich hätte es auch anders vorgeschlagen. Da ich derselben Meinung war, dass das unsinnig ist.
Nur … ich bin leider nicht derjenige, der es bestimmt. Sondern jemand anders höher in der Hierarchie.

Ja, die Absicht ist erkennbar.
Nur bedauerlicherweise akzeptiert diese Person keine andere Lösung.

und ich sehe das auch als organisatorische Fehlleistung, Gängelung. Trägt einfach nicht zur Produktivität bei. Im Gegentil.

dr4g0n76

Das ist tatsächlich so. Der Code ist … na ja. Bisher. Es wird gerade viel umgeändert.
Und vor allem auch das, dass es wie eine normale WPF-App funktioniert.

Auf jeden Fall in der neuesten Version gibt es das jetzt mehr oder weniger zumindest bis jetzt.

Deshalb habe ich mal angefangen, den Vorschlag von Dir auszuprobieren.
Danke nochmals dafür!

Ich werde auf jeden Fall versuchen, das Ganze zum Laufen zu bringen.
Und dann den Code hier ergänzen. Zuerst mal für den allgemeinen Fall.
Denn das Thema muss ich sowieso lösen. Bei uns brennt's halt gerade an vielen Ecken und Enden.
Hier gilt wirklich wieder mal, aufgeschoben ist nicht aufgehoben.

P.S: Ich hab also den Code übernommen und mal versucht erste Schritte zu machen.
Ich werde ein Update hier posten, sobald ich ein paar Schritte weitergekommen bin.

Azure DevOps hat ja genügend Einstellungen, die man machen kann, um den Code Build zu testen, automatisch ausführen zu lassen, sich berichtigen zu lassen usw.

Thema:

Azure DevOps hat ja genügend Einstellungen, die man machen kann,
um den Code Build zu testen, automatisch ausführen zu lassen,
sich berichtigen zu lassen, usw.

Bei uns wird nach einer Möglichkeit gesucht, den Code gar nicht erst auf DevOps einchecken zu lassen,
bevor er nicht eindeutig kompiliert.

Kennt dafür jemand eine Möglichkeit?

Denn im Moment wüsste ich nicht, wie man das erreicht.

Gewollt ist quasi folgender Mechanismus:

1.) Es wird versucht, einzuchecken. Auf ein DevOps Repository.
2.) Dann soll DevOps (wie auch immer) den Build überprüfen.
3.) Und wenn der erfolgreich war, erst DANN das Ganze ins Repository übernehmen.

Ich wüsste nicht, dass DevOps das so von Haus aus kann.
Und wenn, dann fällt mir da nur was Ähnliches wie ein Buildvorgang ein, der aus 2 Pipelines besteht
oder eine Lösung mit einem lokalen Agenten, aber auch das ist nicht gewollt.

Meine Lösung dazu:

Ich hatte dann vorgeschlagen, dass jeder Entwickler das gleiche Tool nehmen kann,
dass das schon in der IDE so wäre.
Problem gelöst.
Nur … leider wird das nicht akzeptiert. Da das ja dann lokal wäre …

Ich entscheide bedauerlicherweise nicht selbst, welche Lösung wir favorisieren.
Kann darüber nicht bestimmen.

Wie würdet ihr das machen? Geht das überhaupt mit Azure DevOps Boardmitteln?

Das auf jeden Fall. Nur... wass willst Du erwarten, bei einer Software die erstmal 100e von Exceptions erzeugt, bis sie wirklich hochfährt.

Ich hab mal versucht folgendes zu machen:

Es gibt eine Art try/catch-Block für die ganze Applikation. Mit diesem eigens vergewalteten Application-Object, dass die Entwickler selbst "verbrochen" haben. 😉
Ich hab mal den try/catch-Block entfernt, weil zumindest in VS2019 manche Sachen nicht einfach so einsehbar waren, durch Warning-Suppressions and what not.
Selbst wenn Du den weg machst, das Ding ist so instabil, dass die Software dann nicht läuft.

Wie kann man so eine Qualität machen. Aber egal... (egal im Sinne von dann distanzier ich mich halt emotional komplett davon, was kann ich dafür. 😉)

try
{
   Application.StartMainProgram();
}
catch(Exception ex)
{
   Log(ex).Here();
}

und Du hast Recht. Ich hab das Application-Object auch noch nicht gefunden.
Das einzige wo ich bisher Application.Current gesehen hatte, war in einer Drag/Drop-Routine. Morgen hab ich endlich mal etwas mehr Luft, dann werde ich mir es genauer anschauen.

Ich kann Dir zumindest einen Teil davon zeigen.

Es wurde durch

using <OWN NAMESPACE>;

namespace <OWN NAMESPACE>
{
    public static class Program
    {
        public static void Main(string[] args)
        {
            var applicationManager = new ApplicationManager();

            applicationManager.Start("OFApplication","OFSplashScreen");
        }
    }
}

Ausgetauscht und die ApplicationManager-Klasse leitet weder von Application ab, noch macht sie sonst was WPF-trächtiges. Nada. Ist auch nicht von etwas anderem abgeleitet und hat auch kein Interface.

Sieht teilweise so aus:

 public class ApplicationManager
    {
        private string _splashScreenType = "Default";

        private Window _splashScreen;
        private string _applicationName;
        private ManualResetEvent _delay = new ManualResetEvent(false);
        private ManualResetEvent _splashSync = new ManualResetEvent(false);

        public ApplicationManager()
        {

        }

Und startet Threads über etwas das ein wenig so aussieht wie ein Factorypattern...

Leider wird bei uns kein App Object benutzt, wie ich gerade gesehn hatte. Aber das lässt sich ja ändern, wenn ich das ganze benutze, um zu testen.
Ich werde es auf jeden Fall ausprobieren. War auch gerade am Suchen, wie man das mit dem BAML löst. Du warst schneller. 🙂

Siehe auch (als Ergänzung):

Lösung für: Anonymen Typ in ein Interface casten

@Palladin007

Wofür steht eigentlich die 007 bei Dir? Seriennummer Skateboard? James Bond? Geburtstag in spezieller Form? Deine Serien ID. ^^

Ich könnte, wenn ich hier teil vom Softwareteam wäre, bzw. nicht nur die Textcontrols. Denn das wäre genau, das was ich machen würde und den Vorschlag habe ich auch schon eingebracht.
Nur... leider bin ich hier "nur" im Test-Team. Deswegen werden meine Vorschläge hier auch nicht entgegengenommen. Und dann fragt sich halt das Software-Team, wie sie die ganzen abgeschnittenen Texte finden sollten.

Deswegen kam ich aus dem Testerkontext her auf die Idee: Ich könnte ja alle Controls durchgehen und dann schauen.
Leider ist die Softwarequalität so schlecht, dass selbst wenn ich mein eigenes Programm einhängen würde, das nicht garantiert ist, dass das funktioniert.

Denn die App wird quasi "vorsichtig hochgecrasht", sorry aber anders kann ich das bei der Softwarequalität nicht mehr bezeichnen.
Denn es entstehen erst mal ein paar hundert Exceptions, bis Host und Exe laufen. LOL.

Jetzt weiss auch, warum dieser IRRE Aufwand. Denn abgeschnittene Texte wird es immer wieder geben und ich will den Aufwand für mich automatisieren.
Hab keinen Bock, das immer wieder händisch durchzukontrollieren.

Jetzt kennst Du den Hintergrund. 🙂

Hab mir eh neulich schon anhören dürfen: Du findest immer so komische Bugs.
Meine Antwort dazu:

1. Dazu wurde ich ja hierhergeholt.
2. Wenn Du so komische Sachen programmierst... Und ausser mir scheint sie ja keiner bisher zufinden...

@Palladin007

Klar, übrigens hab ich mir das mal genauer angeschaut, was Controls ermitteln angeht, lohnt es sich sowohl

SnoopWpf

und auch

Accessibility Insights

anzuschauen für WPF unter Windows 10 usw.
Denn das zeigt auch die ganzen Boxes mit Focus auf dem gehoverten Control an.
Hab gerade geschaut, man kann auch nachschauen, wie es das macht.

https://cloudblogs.microsoft.com/opensource/2019/03/12/microsoft-open-sources-accessibility-insights/

🙂 Das sollte auf jeden Fall helfen sehr nahe an die Lösung zu kommen, die Controls zu ermitteln.

Mit dem Abschneiden, muss dann immer noch geschaut werden. 🙂

@Thomas.at

Ja, das Problem ist, dass das Konzept bei der Übersetzung nicht richtig durchdacht wurde.
Und das mit den Ellipsen ist zwar eine gute Idee und wird teilweise so gemacht.

Warum ich das so vorgeschlagen hatte, die abgeschnitten Texte (truncated texts) so zu finden, durch Berechnung oder was auch immer es sonst noch für Möglichkeiten geben möge,
ist, dass eben in anderen Sprachen, wenn die Ellipsis benutzt wird (also die "…"-Funktion), dann wird in anderen Sprachen zu viel abgeschnitten.

Z. B. kann in Deutsch/Englisch Notalarm/Emergency Alarm geschrieben werden, nur wenn dann in Spanisch angezeigt wird Alarma de Emergencia
und man nur Alarma de … sieht, dann kann das zu Problemen führen. Normalerweise hätte ich gesagt: Dann vergrössert doch einfach die Controls.
Da die ganze Applikation aber nachher auf einem Panel läuft, mit 1366 x 720 als Auflösung, ist halt teilweise der Platz auf manchen Bildschirmen sehr beschränkt.

Leider scheint sich halt darüber keiner vorher Gedanken gemacht zu haben. Wie so oft…

Ausserdem dachte ich könnte das allgemein eine gute Funktion eines Testtools sein.

Weiss eigentlich jemand, wie man das in der eigenen App machen würde?
Egal welche Control man anzeigt, die Text(e) auf dem Bildschirm anzeigt?

Damit könnte man vielleicht auch Rückschlüsse ziehen, wie man das von aussen mit Windows Automation ermittelt.

Das Problem ist zweigeteilt, sozusagen:

ich würde es gerne richtig machen. Deswegen werde ich es auch zu Hause für mich richtig benutzen. Da redet mir ja zum Glück keiner dazwischen.

Nur derjenige, der mir gerade vorgibt, was ich machen soll, der will das nicht.
Also soll er sich selbst darum kümmern. Ich mach nur den Proof of Concept.
Wenn es dann aber nachher nicht richtig funktioniert, dann ist er selbst schuld. Dann kümmere ich mich nicht mehr darum.

Das ist der Hintergrund.

Denn: ich sehe das genauso wie Du. Sonst hat man wieder Ärger hinterher. Whatever. Selbst schuld, wenn er das so will.

Es gibt nichts daran auszusetzen, an dem was Du nennst.
Im Gegenteil. Meinst Du ein eigenes MVVM Framework oder ein vorhandenes? Muss zugeben, so richtig tief in WPF bin ich nicht drin.
Natürlich nicht unwissend, aber längst noch nicht so, wie mit Windows Forms damals.

P.S.: Ich gebe Dir mal noch 2/3 Beispiele, warum das gerade in der Firma so läuft, damit Du den Hintergrund mehr verstehst,
Ich bin momentan dran eine Automatisierung zu erstellen auf Azure DevOps. Eigentlich.
Nur.. hier in dieser Firma sind so viele dringend, dass man dann dauernd eine neue Prio 1 bekommt. Soweit so gut.

Z.B. war eins der ersten Dinge, dass ich aufgedeckt habe:

1.) Die Firma benutzt SQL Express 2014. Weil das ja kostenlos geht. Laut denen. Hab das bisher noch nicht genauer überprüft.
Nur... was ich dann festgestellt hatte, dass die Datenbank beim Kunden zu 98% voll ist und jeden Moment überlaufen kann.

Hab darauf mehrmals hingewiesen. Nur, dieser Typ will das nicht. Er meinte, wir können uns noch 2 bis 3 Monate Zeit lassen.
LOL. Wenn die Datenbank Files aber alle 3 Tage bis zu 100 MB zunehmen…

SQL Express hat ja das 10 GB Limit.

Also bin ich irgendwann höher zu seinem Vorgesetzten (von – nennen wir ihn mal A). Weil er mich immer dementiert hat.
Sein Vorgesetzter C meinte sofort: klar. Datenbank retten ist wichtiger als alles andere. Wir können uns so was nicht leisten.
Gut. Und dieser vorgesetzte C meinte, ist gut. Brich alles ab. Mach eine Lösung dafür zumindest als Workaround.

2.) Mit den Übersetzungen für neue Sprachen ebenfalls der gleiche Mist.

3.) Und jetzt weisst auch, denke ich, warum ich da nur ein Provisorium mache. Das ist und bleibt dann seine Verantwortung.

Vor allem, wenn das noch lange so weitergeht, dann und meine Bugs weiter gelöscht werden oder als zu unwichtig deklariert werden
und deswegen gelöscht und der Kunde und sich sein Vorgesetzter fragt, warum die Probleme nach 2 Monaten immer noch nicht gelöst sind…
Dann habe ich da eh nicht mehr lange was verloren.

So, das musste ich mal loswerden.

Nope. Hast zwar recht. Nur für mich wird es keins bleiben. Nur hier in der Firma halt.
Für meine eigenen Anwendungen, werde ich das auch benutzen. Da aber garantiert nicht als Provisorium. 😁 Da kann ich ja zum Glück selbst den Zeitaufwand und die Qualität bestimmen. 😁

Also das funktioniert soweit schonmal. Danke. 🙂
Das werde ich bei nächster Gelegenheit einbinden. Und das mit dem Binding wie das geht ist auch klar.
Den Code kann man ja nachträglich noch verbessern. Da das Ganze ein Testtool wird, ist hier ausnahmsweise erst mal Geschwindigkeit wichtiger.

EDIT:
P.S.: Testtool im Sinne zum Ausprobieren, nicht um es als Tester zu verwenden. 😉

Warum weist Du die DataTable direkt zu? Dafür gibt’s DataBinding und WPF ohne MVVM macht keinen Spass.
Bei Tasks solltest Du NIEMALS (ausser Du weisst, was Du tust und hast einen guten Grund) direkt mit dem Resultat arbeiten.
Console.WriteLine? In WPF-Anwendungen gibt es keine Konsole. Wenn’s da einen Fehler gibt, fällt Dir der also nicht auf.
Die DataTable habe ich noch nie mit dem DataGrid zusammen genutzt, ich würde aber die DefaultView benutzen – ob eine Eigene ein Problem ist, weiß ich aber nicht.
Und ich würde auch keine DataTable nutzen, die unterstützt (meines Wissens nach) keine Live-Aktualisierung beim Binding und angepasste Columns stelle ich mir auch schwierig vor.

Erstmal danke für Deine Antwort @Palladin007.

Klar, die Console ergibt keinen Sinn. Das liegt daran, dass ich viel experimentiert habe. Das war zuerst eine Konsolenanwendung mittags noch. 🙂
Dafür, um zuerst nur die Devops Items auszulesen.

Ich wollte eigentlich das Programm wegwerfen, wenn es funktioniert und einfach nur eine User Control daraus erstellen.

Und mir gings erst mal darum den Datatable anzuzeigen im Grid. Deswegen habe ich hier gar nichts bereinigt. Sondern nur probiert.
Ich habs auch schon mit Binding probiert gehabt. Das hatte halt auch nicht funktioniert.

Was ich teilweise auch noch ausprobiert hatte, war von hier:

https://www.dotnetspider.com/resources/34103-WPF-Binding-DataTable-WPF-Datagrid.aspx

Ich möchte mit dem untenstehenden Code einen selbstgefüllten DataTable an die ItemsSource eines Datagrid übergeben.
Die Columns sind AutoGenerated.

Wenn ich den DataTable im Debugger Visualizer anschaue, dann ist auch alles so gefüllt, wie es sein soll.
Nur nachher auf dem GUI ist alles leer. Nur die Spalten und die Zeilen wurden richtig generiert, nur, wie eben halt schon gesagt, ohne Inhalt.
Was mache ich falsch?

Das XAML zum DataGrid sieht so aus:

<DataGrid x:Name="wiqlDataGrid" AutoGenerateColumns="True" ColumnHeaderHeight="25" Margin="125,99,10,0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>

EDIT: Ich hätte gerne das im DebuggerVisualizer angezeigte Bild live auf dem Screen in der App (siehe angehängtes Bild aus dem DebuggerVisualizer)

            try
            {
                Task<IList<WorkItem>> queryResult = queryExecutor.Query(query);
                IList<WorkItem> workItems = queryResult.Result;
                if (workItems.Count == 0 || workItems == null)
                {
                    Console.WriteLine("No workitems found.");
                    return;
                }

                DataSet dataSet = new DataSet();
                DataTable dataTable = new DataTable();
                dataSet.Tables.Add(dataTable);

                foreach (KeyValuePair<string,object> keyValuePair in workItems[0].Fields)
                {
                    dataTable.Columns.Add(keyValuePair.Key);
                }

                for (int j = 0; j < workItems.Count; j++)
                {
                    WorkItem workItem = workItems[j];
                    DataRow row = dataTable.NewRow();
                    int i = 0;
                    foreach (var item in workItem.Fields)
                    {
                        row[i++] = item.Value;
                    }
                    dataTable.Rows.Add(row);
                }
                DataView dataView = new DataView(dataTable);
                wiqlDataGrid.ItemsSource = dataView;
            }
            catch (AggregateException ex)
            {
                System.Windows.MessageBox.Show(ex.Demystify().ToString());
            }
            catch (Exception ex)
            {
                System.Windows.MessageBox.Show(ex.Demystify().ToString());
            }

Hallo Palladin007.

Danke für diese Idee. SnoopWpf hab ich mir sogar tatsächlich schon angeschaut, bevor ich hier die Frage gepostet hatte.

Ich denke, was funktionieren könnte, ist folgender Ansatz:

• Text der gehoverten Control ermitteln [gelöst]
• Font bestimmen (sollte hoffentlich vom ermittelten Automation Control aus möglich sein. Mal schauen…
• die Grösse der Textbox bzw. des Controls bestimmen. Falls überhaupt in WPF vorhanden,
  sowas wie ClientRectangle, bzw. was dem entspricht. Zumindest mal die Breite. Dann wäre es für einzeilige Texte lösbar.
  Allein das wäre schon unglaublich hilfreich.

Möglicherweise geht das so:

var hwndList = (IntPtr)(int)(listWindow.GetCurrentPropertyValue(AutomationElement.NativeWindowHandleProperty));
var listRect = (Rect)listWindow.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty);

• Dann mit Font und MeasureString über den String candidate ausrechnen, wie viel exceeded wird.
  Oder z. B. die Breite durch die Anzahl Zeichen teilen. Je nachdem, wie das nachher genau ausschaut.
  Dies sollte dann wiederum zumindest für Fonts, bei denen jedes Zeichen die gleiche Breite hat funktionieren.
  Was bei uns momentan zum Glück der Fall ist.

Hallo zusammen.

Gibt es eine Möglichkeit automatisch abgeschnittene Texte in WPF Applications von aussen zu erkennen?

Was meine ich damit:

• "von aussen" heisst hier in einem externen Programm. Nicht in der Anwendung selbst. Denn die exe darf dazu nicht verändert werden (nicht von mir bestimmt).
• Folgende Lösungen wären gut und legitim in diesem Fall (also eine davon reicht natürlich):
  a) Ein Programm, dass das aufzeigen kann per Screen oder wenn man mit der Maus über das entsprechende WPF Control fährt, das Text anzeigt.
  b) Ein fertiges Testtool, dass dies kann. Könnte auch kostenpflichtig in diesem Fall sein. Kostenlos wäre besser.
  b) Eigene Lösung. Ich hab den Teil mit den Textlängen ermitteln schon entwickelt.
  Was hier fehlen würde: Wieviele Zeichen können angezeigt werden in der mit der Mouse gehoverten Control?
  Denn dann könnte man auch den Unterschied zwischen angezeigten und eingegebenen Textlängen berechnen und daraus ermitteln, wieviel Platz man tatsächlich zur Anzeige hat.

Ging es vielleicht auch damit?

private Size MeasureString(string candidate)
{
    var formattedText = new FormattedText(
        candidate,
        CultureInfo.CurrentCulture,
        FlowDirection.LeftToRight,
        new Typeface(this.textBlock.FontFamily, this.textBlock.FontStyle, this.textBlock.FontWeight, this.textBlock.FontStretch),
        this.textBlock.FontSize,
        Brushes.Black,
        new NumberSubstitution(),
        1);

    return new Size(formattedText.Width, formattedText.Height);
}

Würde das reichen um vom gehoverten Control und dem eingegebenen Text ausrechnen zu können, wieviele Zeichen tatsächlich angezeigt wurden und wieviele eingegeben wurden?

Ich hoffe, dass das so verständlich ist.

Nochmal kurz ganz anders ausgedrückt:

Es geht darum, dass wir einfach ermitteln können, wie lang ein Text sein kann, in einem entsprechenden Control, damit er nicht abgeschnitten werden kann.
Dazu wird ein Programm benötigt, dass dies von aussen ermitteln kann.

Hallo Kollegen,

habe folgendes Problem:

wenn ich eine YAML Datei (die das komplette Json enthält) runterlade von Swaggerhub, dann wird alles richtig konvertiert, bis auf die untenstehenden Enums.

Warum verstehe ich nicht:

xdjmd42n.0.cs(2553,182) : error CS0117: '"LoggingConfigurationMinimumSeverityToLog" enthält keine Definition für "_4".
djmd42n.0.cs(2817,210) : error CS0117: '"MessageHandlingConfigurationMinimumSeverityToLog" enthält keine Definition für "_4".
xdjmd42n.0.cs(2906,201) : error CS0117: '"SystemConfigurationExpectedMessageEncoding" enthält keine Definition für "_5".
xdjmd42n.0.cs(2957,232) : error CS0117: '"SecurityConfigurationSecurityOption" enthält keine Definition für "_0".

Diese 4 oberen werden nicht richtig konvertiert. Alles andere geht. Würde ich diese von Hand ändern, würde es auch funktionieren.

Weiss jemand woran das liegt? Wir haben sehr viele Enums. Nur bei diesen passiert das.

Wie immer, wenn ich eine bessere Lösung finde, poste ich sie hier.

Dachte ich mir. Denn ich habe auch in diese Richtung nichts gefunden.
Ich bin in dem Fall der Ausführende. 😃 Und muss einfach die Lösungen finden, sollte es nichts geben, dann muss ich das natürlich weitergeben.

Bisher nur Dinge, die eben Notification gehen oder selber herunterladen lassen.

Bisher sieht mir das so aus, als müsste ich trotzdem bei der Lösung bisher bleiben, mit dem selber runterladen. Und mir quasi einen eigenen Event machen.

Ja den Download kann man ja quasi nur auf den Docker Container selbst machen. Was auch Sinn machen kann. Ist halt hier ein anderer Anwendungsfall.

Denn wenn der Build Output erstellt ist,
dann soll lokal ein Test anlaufen mit HW/SW usw. der alles mögliche im Test bereitstellt, damit wir die Qualität garantieren können.

und dafür wird das benötigt. Deswegen muss es eine Custom Lösung in dem Fall sein.

Danke für die Hilfe nochmal.

Auf dem Weg von vorher komme ich auch weiter. 😃

Webhooks sind ja "standardisierte Technik". Da ist keine Magic hinter.
Kannst ja nen Doc Deiner Wahl herziehen um zu sehen, wie man sie nutzt.

Wir machen automatisierte Tests über das Release Management bzw. über die Tests Plans; nicht manuell.
Daher kann ich zumindest über den Weg wenig beitragen. Kann Dir nur sagen wie man eben Webhooks in AzD auslöst 😉

Ja, das stimmt schon.
Mir fällt noch was anderes gerade ein, was ja auch ginge.
Falls Azure das ermöglicht.

Kennst Du einen Mechanismus, der es erlaubt, dass das Package sofort automatisch von Azure runtergeladen wird, sobald ein Build erfolgreich durchgelaufen ist?
Dann könnten wir auch einen Filewatcher benuzen.

Edit:
Oder wäre das der Buildartifacts Task?

DownloadBuildArtifacts

Geht das auch ohne eigenen lokalen build agent?

Weil wenn das natürlich nur auf den Azure Container runtergeladen wird, bringt das nichts.
Würde das aber lokal runtergeladen, wäre das eine mögliche imho Lösung, die gut genug ist.

Danke @Abt. Der Link zum Ausführen der Webhooks ist sehr hilfreich. 😃
Den kann ich auf jeden Fall brauchen.

Teil a) Was gemacht werden soll

Ich kanns auch nochmal programmatisch erklären:

1.) Programm läuft (Console App), dass die Notification erhält:

Azure Devops hat einen neuen Build der Pipeline mit der ID xyz erfolgreich gebuildet.
Nur dann wird auch eine Notification gesendet, die das Console Programm empfangen kann.

2.) Die Artifakte von der Build Pipeline werden heruntergeladen und entpackt.
3.) Die einzige exe die darin ist wird gestartet. Automatisch.

Grund für das Programm:

Es soll ein vollautomatisches Testsystem erstellt werden,
das immer den neuesten Build mit der exe in Zusammenhang ausführt und testet.

Es soll auch dann funktionieren, wenn keiner da ist.

Teil b) Was gelöst werden muss, damit a) überhaupt für uns machbar wird:

Wie kann man dazu einen Webhook benutzen? Falls das überhaupt der richtige Ansatz ist.
Sollte man überhaupt einen Webhook benutzen?
Es könnte ja auch sein eine Azure Function ist besser?
Oder das Event Grid?

Das bin ich gerade alles am rausfinden und weiss noch nicht, was das beste dabei ist...

Vor allem ob es nicht schon eine Standardnotification gibt, die einfach abgefragt werden kann,
evtl. auch ohne, dass man noch einen neuen Service integrieren muss?

Das weiss ich noch nicht. 😃

Wir haben gerade die Herausforderung bei uns im Projekt, dass wir Notifications brauchen,
wenn auf Azure ein neuer Build vorliegt, der die Artefakte enthält.

Die sollen dann von einem Programm empfangen werden (Console Anwendung), die dann den Build auf den Rechner lokal herunterlädt.

Jetzt ist die Frage, wie wir das machen können.

Dazu bisher meine Recherchen:

Folgendes habe ich dazu (bisher) in Betracht gezogen, weil ich denke dass eine der Kategorien zumindest helfen sollte diese Notifications/Events zu empfangen.

Also entweder ginge das vermute ich über:

• Azure Functions
• Azure Notification Hubs
• Azure Web Hooks (bisher sieht mir das am vielversprechendsten aus)

Hier gibt's ein Beispiel das helfen könnte:

https://andrewlock.net/creating-my-first-azure-functions-v2-app-a-webhook-and-a-timer/

Was ebenfalls möglich wäre, als Notlösung:

In bestimmten Abständen pollen.
Mit Rest API den letzten Build holen ()

Wie würdet ihr das angehen?

ich werde auf jeden Fall versuchen das zu lösen und dann wie immer die Lösung hier posten.
und dann davon den Artifact herunterladen.

Danke @FZelle.

Du hast Recht. Hab ich total übersehen, diesmal.

Hab einige gefunden.

Hier ein Beispiel:

https://github.com/NightQnEarth/SntpClient-Server

Hat jemand von euch schon mal einen NTP Server selbst programmiert und/oder weiss, wo es Unterlagen dazu im Internet gibt?

Hab jetzt schon einige Tage immer wieder mal gesucht und finde keinen.

Grund für den Bedarf:

Unser Test System soll einen eigenen NTP Server zur Verfügung stellen für ein automatisiertes Testsystem.

Ist folgendes möglich:

Programmatisch eine lokal gespeicherte yml Pipeline so upzuloaden auf Azure,
dass automatisch eine Build Pipeline erstellt und ausgeführt wird?

Klar, upload bis alles oben im Repository ist, geht auch mit den git cmd Befehlen.
Nur, es wird natürlich nicht automatisch das YAML als Pipeline ausgewählt.

Hat das jemand schon mal hinbekommen oder weiss wie und ob das überhaupt geht?
Mir würde schon ein Link reichen.

P.S.: Wie immer, wenn ich eine Lösung gefunden habe, poste ich sie selbst hier.

Es wurde gewünscht, dass wir einen eigenen TestRunner haben.
Der soll die Tests ausführen.
Basierend auf XUnit.
Das funktioniert.
Die Tests liegen in einer anderen Assembly.

Das gewünschte Verhalten wäre, dass die trx (Test Results) Datei geschrieben wird,
während der TestRunner ausgeführt wird, was ja natürlich hier nicht im Code vorhanden ist.

Jetzt wäre die Frage, ob von
https://www.nuget.org/packages/Microsoft.TestPlatform.Extensions.TrxLogger/
z.B. der Logger irgendwie benutzt werden kann, um die trx Datei zu schreiben?

Aber anscheinend kann xUnit - soweit ich recherchiert habe - aber nicht auf die Events von diesem zugreifen.

Das heisst:

Wenn ich wüsste, dass das so nicht geht (xUnit + Microsoft Object Model + Extensions TrxLogger)
müsste ich einen eigenen Mechanismus implementieren.

Denn sonst würden ja einmal die Tests ausgeführt.

Und dann in der Kommandozeile mit

dotnet test --logger trx --no-build /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:CoverletOutput=.\coverage\ Codan.Argus.AcceptanceTests

Würden die Tests noch einmal ausfgeführt. (hier sorgt der Zusatz --logger trx dafür, dass die trx Datei geschrieben wird.

Vielleicht ist es jetzt klarer? 😃

Hallo Kollegen.

Ich hab hier einen Assembly Test Runner, der den Mechanismus von xUnit benutzt (falls ihn jemand benutzen möchte). Es ist auch unbedingt gewünscht, dass wir diesen selber beeinflussen können.
Soweit so gut. (Die Tests sind in einer eigenen Assembly und können durch Angabe des Filenamens der Assembly ausgeführt werden.

Nur, wenn ich den jetzt ausführe, wird ja nicht einfach standardmässig ein *.trx File geschrieben.

Wenn ich aber

dotnet test --logger trx --no-build /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:CoverletOutput=.\coverage\ Codan.Argus.AcceptanceTests

ausführe, dann schon. Vorausgesetzt die richtigen NuGet packages wurden zur TestAssembly hinzugefügt.

(Danach wird dann der Coverage Report mit

reportgenerator "-reports:C:\Code\TestEnvironment\Codan.Argus.AcceptanceTests\coverage\coverage.opencover.xml" "-targetdir:.\coverage"

erzeugt)

Nur, wenn ich diesen Befehl benutze, ist zwar alles gut bis auf eine Sache:
Die Tests werden ja dann nochmal ausgeführt, einmal durch meinen eigenen TestRunner und einmal eben durch die Kommandozeile.

Wie bekomme ich also den Mechanismus genutzt, von dotnet test -logger trx?

Oder muss ich dann quasi "von Hand" einen trx Logger für jeden Test der ausgeführt wird selbst aufrufen?

EDIT: Wenn ich selber vorher eine Lösung finde, poste ich sie natürlich hier.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Xunit.Runners;

namespace Codan.Argus.TestEnvironment
{
    public class ExtendedAssemblyRunner : IDisposable
    {
        private AssemblyRunner _assemblyRunner = null;
        
        public delegate void DiscoveryCompleteEventHandler(object sender, DiscoveryCompleteInfo e);
        public event DiscoveryCompleteEventHandler DiscoveryCompleteEvent;

        public delegate void ExecutionCompleteEventHandler(object sender, ExecutionCompleteInfo e);
        public event ExecutionCompleteEventHandler ExecutionCompleteEvent;

        public delegate void TestStartingEventHandler(object sender, TestStartingInfo e);
        public event TestStartingEventHandler TestStartingEvent;

        public delegate void TestSkippedEventHandler(object sender, TestSkippedInfo e);
        public event TestSkippedEventHandler TestSkippedEvent;

        public delegate void TestFailedEventHandler(object sender, TestFailedInfo e);
        public event TestFailedEventHandler TestFailedEvent;

        //public delegate void 

        static object consoleLock = new object();
        private static ManualResetEvent finished = new ManualResetEvent(false);
        private string _testAssembly = null;

        private ExecutionCompleteData _executionCompleteData = null;

        public ExtendedAssemblyRunner(string testAssembly)
        {
            _testAssembly = testAssembly;

            _assemblyRunner = AssemblyRunner.WithAppDomain(testAssembly);
        }

        public ExecutionCompleteData ExecutionCompleteData 
        {
            get { return _executionCompleteData; }
        }
        
        private void WithAppDomain(string testAssembly)
        {
           _assemblyRunner = AssemblyRunner.WithAppDomain(testAssembly);
        }

        public void Start(string testAssembly = null)
        {
            if (testAssembly == null) testAssembly = _testAssembly;

            _assemblyRunner.OnDiscoveryComplete = OnDiscoveryCompleteEvent;
            _assemblyRunner.OnExecutionComplete = OnExecutionCompleteEvent;
            _assemblyRunner.OnTestFailed = OnTestFailedEvent;
            _assemblyRunner.OnTestSkipped = OnTestSkippedEvent;
            _assemblyRunner.OnTestStarting = OnTestStartingEvent;

            _assemblyRunner.Start(typeName: null);

            finished.WaitOne();
            finished.Dispose();
        }

        public AssemblyRunnerStatus Status
        {
            get { return _assemblyRunner.Status; }
        }

        protected void OnDiscoveryCompleteEvent(DiscoveryCompleteInfo info)
        {
            lock (consoleLock)
            {
                if (DiscoveryCompleteEvent != null)
                {
                    DiscoveryCompleteEvent(this, info);
                }

#if DEBUG
                Debug.WriteLine("Discovering...");
#endif
            }
        }


        protected void OnExecutionCompleteEvent(ExecutionCompleteInfo info)
        {
            lock (consoleLock)
            {
                if (ExecutionCompleteEvent != null)
                {
                    ExecutionCompleteEvent(this, info);
                }
#if DEBUG
                Debug.WriteLine(
                    $"Finished: {info.TotalTests} tests in {Math.Round(info.ExecutionTime, 3)}s ({info.TestsFailed} failed, {info.TestsSkipped} skipped)");
#endif
                finished.Set();
            }
        }

        protected void OnTestFailedEvent(TestFailedInfo info)
        {
            lock (consoleLock)
            {
                if (this.TestFailedEvent != null)
                {
                    TestFailedEvent(this, info);
                }

#if DEBUG
                Console.ForegroundColor = ConsoleColor.Red;
                Debug.WriteLine("[FAIL] {0}: {1}", info.TestDisplayName, info.ExceptionMessage);
                if (info.ExceptionStackTrace != null)
                {
                    Debug.WriteLine(info.ExceptionStackTrace);
                }

                Console.ResetColor();
#endif
            }
        }

        protected void OnTestStartingEvent(TestStartingInfo info)
        {
            lock (consoleLock)
            {
                if (this.TestStartingEvent != null)
                {
                    TestStartingEvent(this, info);
                }
#if DEBUG
                Console.ForegroundColor = ConsoleColor.Yellow;
                Debug.WriteLine("[TESTSTARTING] {0}: {1}", info.TestDisplayName, info.MethodName);
                Console.ResetColor();
#endif
            }
        }

        protected void OnTestSkippedEvent(TestSkippedInfo info)
        {
            lock (consoleLock)
            {
                if (this.TestSkippedEvent != null)
                {
                    TestSkippedEvent(this, info);
                }
#if DEBUG
                Console.ForegroundColor = ConsoleColor.Yellow;
                Debug.WriteLine("[SKIP] {0}: {1}", info.TestDisplayName, info.SkipReason);
                Console.ResetColor();
#endif
            }
        }

        public void Dispose()
        {
            _assemblyRunner.Dispose();
            _assemblyRunner = null;
        }
    }
}

P:S.:

Ich werds jetzt einfach mit einem anderen Befehlsset aus der Documentation von Microsoft lösen. Welches weiss ich noch nicht. Aber die Möglichkeiten sind ja da.

Deswegen kann das Thema als gelöst betrachtet werden.

Auch von mir: ebenfalls danke dafür. 😃

Das Problem ist gelöst, danke. 😃

Danke für die Antworten. Auf diese Lösungen war ich inzwischen (seit gestern), ebenfalls gestossen.

Mein Ansatz war jetzt:

Ein Aktuelles Ubuntu ISO Image in der VM zu laden (mounten als Iso)
und dann einfach die Scripte, die ich für den Build brauche rüberzukopieren und für ssh die selben Datein rüberzukopieren.

Dann kann nämlich auch übers Netzwerk und mit VCenter geklont werden. Wie man möchte.

Natürlich mussten dann die Rechte für SSH nochmal neugesetzt werden.

Jetzt läuft das ganze. 😃

Ich habe eine Ubuntu Installation (phsyikalischer Rechner), die ich entweder:

• in eine ISO konvertieren möchte (falls dieser Zwischenschritt nötig ist)
• oder eben in eine VM (Ziel)

Ich habe bisher mit Acronis ein tib File gesichert.
Aber alle Versuche dieses bisher in ein Image zu konvertieren, sind fehlgeschlagen.

Ich habe auch versucht eine neue VMWare zu erstellen (als Acronis Boot Image, was soweit funktioniert hat)
und darin das *.tib File als Recovery auszuwählen und dann wieder herzustellen.

Ich konnte aber nirgends in den Optionen auswählen, wohin ich das *.tib File recovern will.
Was ich ja in der VM auf die VM machen möchte. Von mir aus auch auf eine weitere virtuelle Harddisk.
Aber dann hatte ich ebenfalls keine Option etwas auszuwählen.

Wie kann ich das denn jetzt machen?

Aber ich habe schon ein paar Tage lang gesucht.
Der oben beschriebene Vorschlag kam am nächsten ans Ziel, habe aber immer noch kein virtualisiertes Ubuntu vom phsyikalischen Rechner.

Vielleicht weiss ja jemand wie das geht?

Wenn ich selber eine Lösung finde, werde ich sie hier natürlich posten.

Ich versuche mit folgender Methode WorkItems von Azure Devops auszulesen.
Was soweit auch funktioniert.

Allerdings ist dann die History leer.

Ich habe schon herausgefunden, wie das z.B mit Rest API (WIT) für Azure Devops funktioniert.

Aber in dem Beispiel hier, wollte ich - falls das möglich ist - nicht mehrere Dinge mischen. Sondern einfach nur die normale WebApi aus eben diesem Namespace benutzen.
Bisher habe ich aber keinen Befehl gefunden der funktioniert.

public async Task<List<WorkItem>> RunQuery(string query, params string[] fields)
{
        var uri = Connect(out var project, out var credentials);

        //create a wiql object and build our query
        Wiql wiql = new Wiql()
        {
            Query = query
        };

        //create instance of work item tracking http client
        using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(uri, credentials))
        {
            //execute the query to get the list of work items in the results
            WorkItemQueryResult workItemQueryResult = await workItemTrackingHttpClient.QueryByWiqlAsync(wiql);

            //some error handling                
            if (workItemQueryResult.WorkItems.Count() != 0)
            {
                //need to get the list of our work item ids and put them into an array
                List<int> list = new List<int>();
                foreach (var item in workItemQueryResult.WorkItems)
                {
                    list.Add(item.Id);
                }
                int[] resultArray = list.ToArray();

                //build a list of the fields we want to see
                //get work items for the ids found in query
                var workItems = await workItemTrackingHttpClient.GetWorkItemsAsync(resultArray, fields, workItemQueryResult.AsOf);
                return workItems;
            }

            return null;
        }
}

Weiss jemand von euch zufällig, wie man das machen kann?

Weil ansonsten gäbe es scheinbar noch die Möglichkeit für Fields System.Rev auszulesen und dann für jede Revision einfach System.Reason abzufragen.

d.h. wenn es 10 Revisionen gäbe,
wäre es 10 mal:

Pseudo Code:

string historyText = null;
for(int foractualrev=0;foractualrev<System.Rev;foractualrev++)
{
    historyText += Read(System.Reason, foractualrev) + Environment.NewLine;
}

Aber ich weigere mich momentan noch zu glauben, dass ich 10 Zugriffe hierfür extra brauchen würde.

Bestimmt habe ich einfach nur die Funktion (die ebenfalls auch NICHT-obsolet ist) übersehen.

P.S.: Wenn ich es selbst rausfinde, poste ich natürlich die Antwort hier.

Hallo.

Was sein kann ist, dass Devenv.exe also Visual Studio das ganze noch richtig buildet.
Aber msbuild würde schon vorher fehlschlagen.

Es lohnt sich imho also das ganze mit msbuild.exe lokal auszuprobieren.

Ansonsten gibt es noch die Alternative einfach DevEnv.exe als Build einzusetzen.

Ich hoffe das hilft Dir weiter. 😃

P.S.: Auch wenn es schon eine Weile her ist, Deine Frage.

Danke, ich betrachte somit das Thema als "gelöst". 😃

Hallo Kollegen. 😃

Ich hatte auf Azure Devops eine Microsoft Extension installiert, die Analytics View.

(Von hier: Azure Devops: Microsoft Analytics)

Jetzt wird der Titel links mit einem Sternchen hinter dem Namen angezeigt, wie oben in der Überschrift, bzw. dem unten angehängten Bild.

Weiss jemand den Grund dafür?

Ich soll das rausfinden. Habe aber bisher nichts gefunden, weder in Foren noch über die Google Suche.
Vielleicht was das jemand von euch.

@gfoidl:

Wie Abt schon schreibt, ist trx auch xml 😉

stimmt absolut, hätte mich damals genauer ausdrücken sollen, ich hätte ein anderes XML-Format gebraucht, mit der Kommandozeile, die ich aufgerufen hatte. Das hat sich jetzt aber vorerst gelöst.

Danke nochmals für alle diese Antworten. Und ich werde auf jeden Fall darauf zurückkommen.

@Abt:

>

Das Löst direkt einer meiner nächsten Aufgaben teilweise mit. Danke dafür.

P.S.: Wenn sich das Thema demnächst lösen sollte, dann werde ich dem Titel ein [gelöst] mitbeifügen. 😃