@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.