Forenbeiträge von HeikoAdams Ingesamt 62 Beiträge
Migration von .NET 4.x auf .NET 5 bereitstellt.
Was genau meinst Du? Von .NET Framework auf .NET 5?
Ja, genau.
Schön wären entweder Tools/Assistenten, die einen bei der Migration unterstützen und/oder eine Übersicht, was es in .NET 5 nicht mehr gibt und wie man es ersetzen kann.
Es dürfte auch spannend werden, ob wenn ja wie Microsoft Hilfsmittel für die Migration von .NET 4.x auf .NET 5 bereitstellt.
So, wie ich das mitbekommen habe, soll das nicht so ganz ohne sein, seine vorhandenen (legacy) Anwendungen auf .NET 5 zu portieren.
Mit anderen Worten: Ausprobieren.
Hallo,
es ist vielleicht eine blöde Frage, aber macht es Sinn, auf dem Buildsystem die 2019er Buildtools zu verwenden, obwohl mit Visual Studio 2017 entwickelt wird? Oder ist das im Endeffekt egal?
Das Microsoft seine .NET Produkte früher oder später zusammenführen würde, war ja zu erwarten. Allerdings kommt es in der Presse teilweise so rüber, das Mono, Xamarian und .NET Core zugunsten des .NET Frameworks beerdigt werden, was ja eben nicht der Fall ist.
Hallo,
ich habe gestern diverse Git-Repositories in eine Komponenten-Sammlung verschoben und seit dem lassen sich Anwendungen, die diese Komponenten benötigen, nicht mehr vom Azure DevOps Server (on premise) compilieren.
Der Build bricht jedesmal mit folgender Fehlermeldung ab:> Fehlermeldung:
2019-03-20T14:50:49.5273620Z fatal: unable to access 'http://srcctl/Komponenten/_git/SKControls/': The requested URL returned error: 500
2019-03-20T14:50:49.5274518Z fatal: clone of 'http://srcctl/Komponenten/_git/SKControls' into submodule path 'C:/agent/_work/1/s/SKControls' failed
Reboots des Servers, sowie das Rechners mit dem Build-Agent haben nichts gebracht.
Hat hier jemand eine Idee, wie das Problem zu lösen ist?
Hallo,
ich habe vor ein paar Tagen unseren TFS 2017 auf den aktuellen Azure DevOps Server aktualisiert.
Heute musste ich blöderweise feststellen, das sich ein ASP.NET Projekt seit dem Upgrade nicht mehr compilieren lässt:> Fehlermeldung:
2019-03-18T10:51:01.0744146Z C:\Windows\Microsoft.NET\Framework\v4.0.30319\aspnet_compiler.exe -v /localhost_54996 -p SCWebservice -u -f PrecompiledWeb\localhost_54996\
2019-03-18T10:51:02.1004505Z ##> Fehlermeldung:
ASPNETCOMPILER(0,0): Error ASPCONFIG: Die Datei oder Assembly "AlphaFormatProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" oder eine Abhängigkeit davon wurde nicht gefunden. Zugriff verweigert
Wenn ich das aspnet_compiler Kommando bei mir lokal (als Admin) ausführe, funktioniert alles wunderbar.
Hat jemand eine Idee, wie das Problem zu lösen ist.
Hallo,
ich bin gerade beim Refactoring unserer Legacy-Produktverwaltungssoftware.
Dort gibt es einen Datenabglich mit anderen Systemen, wo für jede abzugleichende Tabelle eine seperate Klasse existiert.
Ich habe das jetzt so geändert, das ganz unten in der Hierarchie ein generisches Interface steht. Von diesem Interface wird eine generische Basisklasse abgeleitet, in welcher u.a. Eigenschaften, die von allen Abgleich-Klassen benötigt werden, definiert sind und die Funktionen aus dem Interface als abstract oder virtual Funktionen durchgeschleift werden. Von dieser Basisklasse werden dann die jeweiligen Klassen für die einzelnen Tabellen abgeleitet.
Gibt es noch etwas, was man an dieser Stelle besser machen könnte?
Auf der anderen Seite sehe ich hier eine zu große Dominanz durch Chrome bzw. Chromium.
Da steckt mir für meinen Geschmack einfach zu viel Google drin.
Die entwickeln sich nun dort hin wo Microsoft mit dem IE eine Zeit lang stand.
Also in der beherrschenden Position um eigene Feature und Erweiterungen durch zu drücken.
Vielleicht ist das aber auch gut für Chromium, wenn MS da mitmischt und den Einfluss von Google zurückdrängt. Lassen wir uns mal überraschen, was da noch kommt.
Interessant wird wie sich z.B. der "Dinosaurier" Winforms weiterentwickeln wird, wenn er Einfüsse von der Open Source Community erhalten kann / wird.
...
** bewusst so geschrieben und es gibt keinerlei offizielle Andeutungen dazu, dass Winform tot sei, genau das Gegenteil wurde durch das Open Source ja gemacht. Auch bewusst in " gesetzt
Ich kenne auch nur die (inoffizielle?) Aussage, das WinForms im Wartungsmodus sei und nur noch Bugfixes, aber keine neuen Features mehr bekommt.
Da kommt doch echt Freude auf, wenn man sich mit jedem großen Windows-Update neue Probleme einhandelt, die MS dann anschließend seperat patcht.
Genau so habe ich es gemeint, wie gfoidl es geschrieben hat. 👍
Hallo,
Ich möchte auf basis eines Cross-Platform-Frameworks eine Anwendung erstellen, die man auf allen gängigen Betriessysteme nutzen kann.
Auf Allen? Allen allen? Das solltest Du dringend spezifizieren.
Ich tippe mal, das der TE mit "allen gängigen" die üblichen Verdächtigen Windows/Mac OS/Linux(/Android/iOS) meint.
.NET Core hat einen anderen Fokus als das .NET Framework.
Zu behaupten, dass .NET Core eine Spielewiese sei: siehe oben.
Hättest Du meinen Post richtig gelesen, dann hättest Du gemerkt, das ich mit "Spielwiese" gemeint habe, das man dort quasi Dinge ausprobieren kann, ohne auf .NET Full Rücksicht nehmen zu müssen.
Wenn sich diese Dinge dann bewährt haben, kann man sie ggf. in die nächste Major-Version von .NET Full portieren.
Aber falls Dich einfach nur der Begriff gestört hat: Testlabor 8)
Man könnte auch ein wenig provokant sagen, das .NET Core die Spielwiese ist und allles, was sich bewährt hat und keine Inkompabilitäten verursacht, mit hoher Wahrscheinlichkeit früher oder später im .NET Full landet.
Wobei Microsoft ja immer betont, das die Entwicklung des .NET Frameworks langsamer verlaufen wird, weil man darauf achten will/muss, das es möglichst keine breaking changes gibt und das Dinge, die z.B. mit dem Framework 4.8 funktionieren, auch mit dem Framework 4.9 funktionieren. Bei .NET Core ist das ja nicht zwangsläufig der Fall, weswegen man die einzelnen Runtimes und SDKs ja auch parallel installieren (und sich den Rechner damit zumüllen) kann.
Es stimmt durchaus, das Anwender sich nicht für Updates interessieren, sondern dafür mehr Wert auf ein stabiles und funktionierendes System, das einfach nur wie von ihm erwartet funktioniert.
Allein schon aus dem Grund sollte der private Anwender die Option haben, mit Enterprise-Kunden gleichbehandelt zu werden und nur erwiesenermaßen stabile Updates zu bekommen. Bei den letzten größeren Windows-Updates hatte man schon manchmal den Eindruck, das es sich um Bananaware (im negativen Sinne) handelt, die beim Kunden reift.
Dann müsste man als IT'ler vielleicht nicht jedes Jahr Weihnachten damit verbringen, die kaputte IT der Verwandschaft zu fixen 😉
Es gibt sie noch nicht, was sich aber schnell ändern kann, wenn wirklich klar wird, das z.B. OpenShift eingestellt wird, weil dann z.B. viele Firmen, die OpenShift nutzen, auf einmal bereit sind, Manpower für die Weiterentwicklung bereitzustellen. Aber das ist im Moment alles "hätte hätte Fahrradkette"
Da die Red Hat Produkte alle Open Source sind, sehe ich da keine große Gefahr, da die Community die Projekte zur Not unter einem anderen Namen in Eigenregie weiterentwickeln kann. Zur Not als Fork.
moving to an out-of-process 64-bit process
Hab ich das richtig verstanden, das es vom VS 2019 auch eine 64bit Version geben wird?
Oder werden über die Freigabe auch Dateien, die dann lokal abgespeichert werden, abgelegt und abgerufen?
Nein, es werden von der Freigabe ausschließlich die Programmdateien (*.exe, *.dll) auf den lokalen Rechner kopiert.
Jaein. Ich möchte die UAC aktivieren, aber nicht diesen ständigen "Wollen Sie wirklich" Dialog, weil das für die Anwender einfach nur nervig ist.
Was ich noch vergaß: Die betreffende Anwendung wird auch zum Starten der Anwendungen verwendet und kopiert damit im Prinzip bei jedem Stand die Dateien der Anwendungen neu vom Netzlaufwerk auf den Rechner.
Hallo,
eine Altlast meiner Vorgänger ist, das unsere Anwendungen durch Kopieren der neuen Programmdateien von einem Netzlaufwerk nach c:\Programme, genauer gesagt
Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)
aktualisiert werden.
Da seit Vista die UAC hier aber die Blutgrätsche auspackt, hat man sich damals dazu enschlossen, die UAC zu deaktivieren, was ich jetzt gerne revidieren würde.
Jetzt ist meine Frage, wie ich das Aktualisierungsprogramm so umbaue, dass das bisherige Verhalten erhalten bleibt, ich die UAC reaktivieren kann und bei Updates nicht der "Wollen Sie wirklich" Dialog der UAC aufpoppt?
Ich hab mich jetzt mal wieder mit dem Problem ein wenig auseinandergestzt und es lag anscheiend daran, dass das Config-Element in der Web.config noch das da als Attribut hatte:
xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0"
Nachdem ich das Attribut gelöscht habe, hat das Upgrade funktioniert.
Ist beim TFS 2017 genau so. Danke!
Das war im Grunde genau das, was ich meinte. Aber ich finde im Release nirgendwo eine Option, um zu steuern, welcher Pool genommen werden soll.
Hintergrund ist, das ich die Lasten etwas besser im Netzwerk verteilen möchte, ohne auf diversen Servern die Build-Tools zu installieren. Daher war der Gedanke, die Aufgaben zu splitten.
Hallo,
gibt es eine Möglichkeit, einen Build-Agent so zu konfigurieren, das er nur das Deployment der Binaries durchführt, während ein oder mehrere Agents nur die Builds durchführen?
Im Internet habe ich nichts dazu finden können.
Gruß
Heiko
Hallo,
ich habe eine generische Klasse (im Anhang), die statice Operatoren implementiert und weshalb mich FxCop mit dem CA1000 anmeckert.
namespace SKTools.Types
{
using System;
using System.Text;
/// <summary>
/// A Intervall-implementation for different Types.
/// </summary>
/// <typeparam name="T">Type of the Rang. Must be comparable.</typeparam>
public class Range<T> where T : struct, IComparable<T>
{
/// <summary>
/// Implements the operator !=.
/// </summary>
/// <param name="d">The value.</param>
/// <param name="r">The range.</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(T d, Range<T> r) => !r.Contains(d);
/// <summary>
/// Implements the operator !=.
/// </summary>
/// <param name="r">The range.</param>
/// <param name="d">The value.</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(Range<T> r, T d) => !r.Contains(d);
/// <summary>
/// Implements the operator !=.
/// </summary>
/// <param name="r1">The first range.</param>
/// <param name="r2">The second range</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(Range<T> r1, Range<T> r2) => !r1.Equals(r2);
/// <summary>
/// Implements the operator <.
/// </summary>
/// <param name="d">The value.</param>
/// <param name="r">The range.</param>
/// <returns>The result of the operator.</returns>
public static bool operator <(T d, Range<T> r)
{
if (d.CompareTo(r.LeftValue) < 0)
{
return true;
}
else if (d.CompareTo(r.LeftValue) == 0 && !r.LeftClosed)
{
return true;
}
return false;
}
/// <summary>
/// Implements the operator <.
/// </summary>
/// <param name="r">The range.</param>
/// <param name="d">The value.</param>
/// <returns>The result of the operator.</returns>
public static bool operator <(Range<T> r, T d)
{
if (r.RightValue.CompareTo(d) < 0)
{
return true;
}
else if (r.RightValue.CompareTo(d) == 0 && !r.RightClosed)
{
return true;
}
return false;
}
/// <summary>
/// Implements the operator <=.
/// </summary>
/// <param name="d">The value.</param>
/// <param name="r">The range.</param>
/// <returns>The result of the operator.</returns>
public static bool operator <=(T d, Range<T> r)
{
if (d.CompareTo(r.RightValue) == 0 && r.RightClosed)
{
return true;
}
else if (d.CompareTo(r.RightValue) < 0)
{
return true;
}
return false;
}
/// <summary>
/// Implements the operator <=.
/// </summary>
/// <param name="r">The range.</param>
/// <param name="d">The value.</param>
/// <returns>The result of the operator.</returns>
public static bool operator <=(Range<T> r, T d)
{
if (r.LeftValue.CompareTo(d) == 0 && r.LeftClosed)
{
return true;
}
else if (r.LeftValue.CompareTo(d) < 0)
{
return true;
}
return false;
}
/// <summary>
/// Implements the operator ==.
/// </summary>
/// <param name="d">The value.</param>
/// <param name="r">The range.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(T d, Range<T> r) => r.Contains(d);
/// <summary>
/// Implements the operator ==.
/// </summary>
/// <param name="r">The range.</param>
/// <param name="d">The value.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(Range<T> r, T d) => r.Contains(d);
/// <summary>
/// Implements the operator ==.
/// </summary>
/// <param name="r1">The first range.</param>
/// <param name="r2">The second range</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(Range<T> r1, Range<T> r2) => r1.Equals(r2);
/// <summary>
/// Implements the operator >.
/// </summary>
/// <param name="d">The value.</param>
/// <param name="r">The range.</param>
/// <returns>The result of the operator.</returns>
public static bool operator >(T d, Range<T> r)
{
if (d.CompareTo(r.RightValue) > 0)
{
return true;
}
else if (d.CompareTo(r.RightValue) == 0 && !r.RightClosed)
{
return true;
}
return false;
}
/// <summary>
/// Implements the operator >.
/// </summary>
/// <param name="r">The range.</param>
/// <param name="d">The value.</param>
/// <returns>The result of the operator.</returns>
public static bool operator >(Range<T> r, T d)
{
if (r.LeftValue.CompareTo(d) > 0)
{
return true;
}
else if (r.LeftValue.CompareTo(d) == 0 && !r.LeftClosed)
{
return true;
}
return false;
}
/// <summary>
/// Implements the operator >=.
/// </summary>
/// <param name="d">The value.</param>
/// <param name="r">The range.</param>
/// <returns>The result of the operator.</returns>
public static bool operator >=(T d, Range<T> r)
{
if (d.CompareTo(r.LeftValue) == 0 && r.LeftClosed)
{
return true;
}
else if (d.CompareTo(r.LeftValue) > 0)
{
return true;
}
return false;
}
/// <summary>
/// Implements the operator >=.
/// </summary>
/// <param name="r">The range.</param>
/// <param name="d">The value.</param>
/// <returns>The result of the operator.</returns>
public static bool operator >=(Range<T> r, T d)
{
if (r.RightValue.CompareTo(d) == 0 && r.RightClosed)
{
return true;
}
else if (r.RightValue.CompareTo(d) > 0)
{
return true;
}
return false;
}
}
}
Irgendeine Idee, wie man die Warnung los wird, ohne sie zu unterdrücken?
verwendetes Datenbanksystem: <MS SQL Server>
Hallo,
wir haben hier eine Legacy-Anwendung, die noch EntitySpaces verwendet. Da ES schon seit einigen Jahren nicht mehr gepflegt wird, würde ich es gerne durch das EF ersetzen, aber möglichst ohne noch einmal komplett bei 0 anfangen zu müssen.
Gibt es eine Weg eleganten Weg für die Migration von ES zu EF oder muss ich tatsächlich wieder komplett bei 0 anfangen und alle Erweiterungen neu schreiben bzw. manuell portieren?
Du könntest mal prüfen ob du das Problem generisch lösen kannst. Außerdem gibt es Werkzeuge für die Datensynchronisation die Dir dabei helfen können.
Das mit den Generics war genau das, was ich gesucht habe. Danke.
Die Implementierung stammt nicht von mir, sondern von einem meiner Vorgänger - an deren fachlicher Kompetenz ich schon des öfteren ernsthaft gezweifelt habe. Ich möchte das ganze jetzt nur auf eine ordentliche Basis stellen, damit ich mir nicht ständig die Haare beim Haareraufen ausreiße 8)
Wenn wir hier vom Business Modell "Product" sprechen, dann wäre die Logik zB. im ProductService o.ä.
Also eine weitere Klasse, die zwischen der Basis- und der Abgleich-Klasse sitzt?
Okay, nochmal von vorne:
Die einzelnen Klassen, welche die Daten aus den Quell- in die Zieltabellen kopieren, hatten bislang keine Vorfahren. Ich bin jetzt hergegangen und habe zumindest die ganzen internen Variable und ein paar grundlegende Funktionen/Methoden in einer neuen Basisklasse deklariert und diese Basisklasse anschließend den einzelnen Abgleich-Klassen als Ahnen zugewiesen.
Sprich aus
public class Produkttypen
wurde
public class Produkttypen: AbgleichBase
Jetzt wäre meine Frage, wie ich die Methoden wie
private void Update(SCTest.Produkttypen scrow, PVTest.Produkttypen pvrow)
in der neuen Basisklasse deklarieren kann, da der Typ der Parameter in jeder Abgleich-Klasse ein anderer ist.
Vielleicht wird es mit einem Beispiel etwas deutlicher:
Klasse A:
private void Update(SCTest.PortalArtikelAuflagen scrow, PVTest.Artikelpreise pvrow)
Klasse B:
private void Update(SCTest.Produkttypen scrow, PVTest.Produkttypen pvrow)
etc pp.
Und in den Funktionen werden dann halt die Werte aus den Quell- in die Zielfelder kopiert, sofern sie sich unterscheiden.
Hallo,
in unserer Software zur Artikelverwaltung gibt es ein Abgleich-Modul, welches dafür sorgt, das geänderte Daten z.B. an unsere Homepage übertragen werden.
Jede Tabelle hat ihre eigene Abgleichsklasse, die bislang völlig autonom von einander waren. Ich habe jetzt schon einmal angefangen, den Klassen eine Basisklasse unterzuschieben, in der z.B. die von allen Klassen verwendeten Variablen und die Funktionen zum Start des Abgleichs und zum Löschen von Karteileichen definiert werden. Die Funktionen sind als "abstract" gekennzeichnet.
Jetzt gibt es in den Klassen aber auch noch die Funktionen für den eigentlichen Abgleich, die als Parameter die jeweiligen Quell- und Ziel-Tabellen übergeben bekommen. Kann ich die auch irgendwie in der Basis-Klasse implementieren oder brauche ich dafür dann etwa ein zusätzliches Interface?
Ach ja: Der Abgleich verwendet LINQ für die Kommunikation mit der DB.
Warum legt Ihr dann nicht einfach fest, das man seinen Code gegen die aktuellste Code-Revision zu testen hat, bevor man etwas committed am besten per Vier-Augen-Prinzip und abgezeichnetem Commit (
git commit --signoff
) und dann auch nur solche Commits im PR akzeptieren.
Hallo,
ich wollte heute ein älteres ASP.Net Projekt upgraden, was jedoch mit Fehlermeldung im Screenshot abgebrochen wurde:
Fehlermeldung:
Fehler beim Anwenden der Transformation auf "web.config" im Projekt "SCWebservice". Kein Element im Quelldokument stimmt mit "/configuration/system.codedom" überein.
Hat jemand eine Idee, wie ich das Problem lösen kann?
Hallo,
ein Kollege und ich diskutieren im Moment darüber, ob man zum Prüfen, ob ein String leer ist, besser auf Länge=0 oder "" prüfen sollte.
Ich bin der Meinung, das auf Länge=0 prüfen effizienter ist und habe die Analogie zu einem leeren Paket gezogen, wo es ja auch einfacher ist, das Gewicht zu kontrollieren, als in das Paket rein zu schauen.
Was meint Ihr?
Nutzt Du in Deinem SQL
CLOSE(cursor)
um den Cursor zu schließen?
Hi,
darf man sich als Desktop-Entwickler auch als Fullstack-Entwickler bezeichnen, obwohl der Begriff ja eigentlich eher den Webentwicklern vorbehalten ist? Immerhin entwickelt man ja auch sowohl im Front- als auch im Backend der Software.
Hallo,
wie würdet Ihr einem Nicht-ITler den Sinn und Nutzen von Code-Refactoring erklären?
Ich ware vor kurzem in der Situation und habe die (suboptimale) Parallele zu den Inspektionen beim Auto (= werterhaltende Maßnahme bzw besserer Preis beim Weiterverkauf) gezogen und ich glaube mein Gegenüber hat es verstanden.
Zuerst einen allgemeinen Einstieg und dann zum TFS
Hallo,
ich suche ein paar gute Online-Ressourcen zum Thema Application Lifecycle Management.
Du solltest auf jeden Fall in Deinem Bewerbungsschreiben den selbstbewusten Eindruck vermitteln, das Du bereit und willens bist, Dich beruflich weiter zu entwickeln und auch neue Aufgaben zu übernehmen.
Also nicht: Ich kann x, y und z nicht, sondern: Ich kann a, b, c und bin bereit, x, y und z zu lernen.
Was man auch nicht unbeachtet lassen sollte: Einige Open-Source-Lizenzen verlangen, das man den Lizenztext beileigt. Also im Zweifelsfall lieber mal in die Lizenz selber schauen, was die so an Forderungen stellt.
Welche? Sonst ist raten angesagt.
Diverse "Methode nicht gefunden" Meldungen. Der Kollege hat mittlerweile das Framework 4.6.2 installiert, damit er weiter arbeiten kann.
Hallo,
ich wundere mich gerade ein wenig über das .net Framework. Unsere Anwendung erfordert das Framework Version 4.6.2, bei einem Kollegen war jedoch nur die Version 4.5 installiert. Die Anwendung lies sich trotzdem starten, hat ihn jedoch mit diversen Fehlermeldungen bombadiert.
Kennt jemand hier dieses Verhalten und hat eventuell eine Erklärung, warum sie die Anwendung überhaupt starten lies?
Okay, ich glaube, das Problem hat sich quasi von alleine gelöst. GetChangeset.Update.Count wird anscheinend nur dann erhöht, wenn sich auch tatsächlich Daten geändert haben. Den gleichen Datensatz noch einmal in die Tabelle schreiben lässt den Wert auf seinem aktuellen Wert stehen.
Die entsprechende Code-Stelle sieht so aus:
internal override void CommitWork(int counter)
{
int records;
if (this.IsInsertMode() || this.IsUpdateMode())
{
if (this.IsInsertMode())
{
records = this.DataContext.GetChangeSet().Inserts.Count;
}
else
{
records = this.DataContext.GetChangeSet().Updates.Count;
}
this.AddLogEntry(string.Format(
Properties.Resources.SAVE_DATASETS,
records.ToString()));
if (this.IsInsertMode() && this.dbItems.Count() != 0)
{
this.DataContext.VDDArtikeldaten.InsertAllOnSubmit(this.dbItems);
}
this.Mode = Modes.Commit;
this.DataContext.SubmitChanges();
}
}
Doch, wenn die VDDArtikaldaten Klasse genau so wie der DataContext per dbml-File generiert wurden.
Aber das ist ja garnicht das Problem. Das Problem ist, wenn ich einen vorhandenen Datensatz ändere und dann speichere, hat GetChangeset.Updates.Count immer 0 als Wert.
Ihr habt da irgendwas falsch verstanden.
Wenn ich ziel mittels ziel = new VDDArtikaldaten() initialisiere und dann die einzelnen Feldder befülle, hat GetChangeset vor dem SubmitChanges korrekte Werte (Insert.Count > 0).
Wenn ich ziel aber per ziel = dataContext.VDDArtikeldaten.SingleOrDefault(import => import.ProduktID == produktId && import.Auflage == auflage2); initalisiere und dann die einzelnen Feldder befülle, hat GetChangeset vor dem SubmitChanges falsche Werte (Updates.Count > 0).
Vielleicht sollte ich noch erwähnen, das VDDArtikaldaten eine per dbml-File autmatisch generierte Klasse ist.