Ich habe einen msbuild-Prozess, der in zwei Abschnitte unterteilt ist. Der erste analysiert Nuget-Pakete und erstellt Dateien. Da ich Nuget-Pakete erst nach dem "Restore" analysieren kann, wird es nach "CoreCompile" aufgerufen. Der zweite Teil sollte diese Dateien in die Anwendung als embedded resource einbetten und da liegt mein Problem. Der Einbettungsteil muss vor dem Target "PrepareForBuild", aber nach "CoreCompile" erfolgen. Meine Lösung dafür war, einen weiteren Build zu starten, nachdem "CoreCompile" stattgefunden hat. Das sieht wie folgt aus:

    <Project>
      <PropertyGroup>
        <GivenDirectory>some directory</GivenDirectory>
    	<Variable>false</Variable>    
    	<Variable2>false</Variable2>
      </PropertyGroup>  
    
    
    	<Target Name="SomeTarget" AfterTargets="CoreCompile" Condition="'$(Variable)' == 'true'">		
    		<MakeDir Directories="$(GivenDirectory)"/>
    		<!--this consoletool generates files in the GivenDirectory-->
    		<Exec Command="$(ConsoleTool)" />
    		
    
    		<!--this calls the msbuild with the other target-->
    		<MSBuild Properties="Variable2=true"  Targets="EmbeddFiles" Projects="$(MSBuildProjectFullPath)" />       
    	</Target>
    	
    	<Target Name="EmbeddFiles" BeforeTargets="PrepareForBuild" Condition="'$(Variable2)' == 'true'">
    		<ItemGroup>
    		  <EmbeddedResource Include="GivenDirectory\*.*"/>         
    		</ItemGroup>
    	</Target>
    	
    </Project>  

Das funktioniert gut, bis auf den Punkt, dass die Ressourcen nicht zu meiner Anwendung als embedded-Resource hinzugefügt werden.
Ich kann den Prozess mit

msbuild.\myapp.csproj /t:rebuild /Variable=true

aufrufen und ich kann sehen, dass beide Ziele so ausgeführt werden, wie ich es wollte, aber irgendwie wird die eingebettete Ressource nicht hinzugefügt. Es erscheint kein Fehler.

Wenn ich das erste Target "SomeTarget" auskommentiere oder den Prozess mit

msbuild.\myapp.csproj /t:rebuild /Variable2=true

aufrufe sind die Dateien als embeddedResoucre vorhanden.

Wo liegt der Fehler?

Ich habe versucht, es wie in diesem Thread zu machen.

Vielen Dank für die Vorschläge. Das Tool, dass ich entwickle soll ein Backup und Restore auf einer Datenbank auf Basis von JSON oder XML Dateien durchführen. Es liegt also am Benutzer auf welcher Art von Provider der Restore durchgeführt wird. Ich habe mir linq2db mal etwas genauer geschaut, jedoch sehe ich hier noch keinen Weg wie ich ohne die POCOs auskommen soll. Ich müsste mir ja sozusagen zur Laufzeit die POCOS aus dem JSON generieren, was glaube ich nicht so leicht möglich ist, oder verstehe ich da etwas falsch?

Könntet ihr mir einen OR-Mapper empfehlen, der mir einen schnelleren Insert für mehrere Provider garantiert? Ich hatte mich vor allem bei Dapper schon ein wenig eingelesen, jedoch sehe ich dort kein insert, dass schneller arbeitet als die gewöhnlichen getrennten Statements (siehe https://stackoverflow.com/questions/17150542/how-to-insert-a-c-sharp-list-to-database-using-dapper-net). Das einzige was ich gefunden hab, dass wohl providerunabhängig einen Bulk Insert absetzen kann wäre Dapper Plus. Aber dafür zu bezahlen kommt für das Projekt nicht in Frage.

verwendetes Datenbanksystem: SQLServer, postgressql, oledb

Guten Abend an die community,

ich bin ziemlich neu in der .NET Entwicklung und versuche im Augenblick ein Tool zu entwickeln, dass Daten aus einem json File in eine vorhandene Datenbank reinschreibt (providerunabhängig).
Ich habe es nun so weit dass es eigentlich funktioniert, jedoch werden die INSERT-Befehle alle einzeln abgesetzt und bei vielen tausenden von Einträgen innerhalb der JSON-Dateien ist es doch spürbar.

Mein Code sieht im Augenblick folgendermaßen aus:

using (IDbConnection connection = dbFactory.CreateConnection())
{
    foreach (TableDTO table in dbTables)
    {
        //build the insert statement
        StringBuilder insertSQLBuilder = new StringBuilder();
        insertSQLBuilder.Append("INSERT INTO " + table.Name + "(");

        foreach (ColumnDTO column in table.Columns)
        {
            insertSQLBuilder.Append(column.Name + ", ");                    
        }
        insertSQLBuilder.Length = insertSQLBuilder.Length - 2;
        insertSQLBuilder.Append(") VALUES (");

        for (int i = 0; i < table.Columns.Length; i++) {
            insertSQLBuilder.Append("@param" + i + ", ");          
        }
        insertSQLBuilder.Length = insertSQLBuilder.Length - 2;
        insertSQLBuilder.Append(")");

        //prepare the insert command
        using (IDbCommand dbCommand = connection.CreateCommand()) {
            dbCommand.CommandText = insertSQLBuilder.ToString();

            IDbDataParameter[] dbParameters = new DbParameter[table.Columns.Length];

            for (int i = 0; i < table.Columns.Length; i++)
            {
                IDbDataParameter dbParameter = dbCommand.CreateParameter();
                dbParameter.DbType = typeArray[i];  //DbType Array, which holds the types for each column
                dbParameter.ParameterName = "param" + i;
                dbParameters[i] = dbParameter;
            } 

            while (dataDeserializer.MoveNext())
            {
                // get new row from json file, each element of ColumnData holds the value and extra information which is not needed here
                ColumnData[] columnData = dataDeserializer.Current;
                for (int i = 0; i < dbParameters.Length; i++)
                {
                    bool isNotGuid = typeArray[i] != DbType.Guid;
                    object value = null;
                    //TODO stupid conversion workaround
                    if (isNotGuid)
                    {
                        value = columnData[i].Value;
                    }
                    else
                    {
                        value = Guid.Parse(columnData[i].Value);
                    }
                    dbParameters[i].Value = value ?? DBNull.Value;
                    dbCommand.Parameters.Add(dbParameters[i]);
                }
                //execute statement and close connection
                dbCommand.Connection.Open();
                dbCommand.ExecuteNonQuery();
                dbCommand.Connection.Close();
                dbCommand.Parameters.Clear();
            }
        }
    }           
}

Innerhalb des JSON-Files stehen alle notwendigen Informationen (Tabellennamen, Spaltennamen- und typen sowie die Daten). Die Typen brauche ich, da ich mir innerhalb des JSON alles als String abspeichere und dementsprechend die Daten später wieder umkonvertieren muss.

Nun zu meiner Frage. Gibt es eine Library, die einen Bulk-Insert oder Batch-Insert für alle gängigen Provider absetzen kann? Im besten Falle kann ich selbst angeben, wie viele Zeilen in Memory gespeichert werden, da ich es vermeiden möchte alle Daten in einer Liste speichern zu müssen bevor ich sie in die Datenbank reinschreiben kann.

Falls ihr eine Idee habt wäre ich unheimlich dankbar.