hat jemand eine Idee woran es liegen kann? NVARCHAR ist Unicode, VARCHAR nicht.

Das ist ganz einfach eine nicht abgefangene Exception. Um rauszubekommen, was genau die Fehlerursache ist, brauchst du erstmal ein paar mehr Infos aus der Exception.

Z.B. in Verhindern, dass bei nicht verwalteten Exceptions Standarddialogfelder aufpoppen steht, was du machen kannst.

Wie gesagt: Any(). Also this.DataContext.GERAETEDECKBLATT.Any(d => d.FKGERAET == id). Oder einfach deckblatt.Any().

Alternativ Count()>0.

Aufgrund der uns erschlagenden Menge an Infos über dein Datenmodell würde ich mal auf Enumerable.Any() tippen.

Ich kann natürlich nicht per LINQ nach den berechneten Feldern filtern (where-Abschnitt), aber das ist normal, oder? Ich wüsste auch nicht, wie das EF das performant übersetzen sollte.

Ja, das ist normal. Denn der EF-Provider weiß ja nicht, was er da für einen SQL-Code daraus erzeugen soll, da deine berechneten Properties ja dann IL-Code sind.
Folglich musst du die berechneten Properties so deklarieren, dass das Möglich ist - also als Expressions. Mittels LINQKit bzw. dem AsExpandable daraus kannst du dann die Expressions direkt einbauen lassen.

Hm, wie es aussieht, musst du einen eigenen TaskScheduler schreiben, damit die Tasks in einem Hintergrundthread abgearbeitet werden.
Siehe z.B. Thread Priority und Task Parallel Library oder ParallelExtensionsExtras Tour- Additional TaskSchedulers.

Folgender Code erstellt ein Delegat, das eine Exception wirft. Falls du stattdessen eine eigene Methode aufrufen willst, musst du die IL-Code dann zusätzlich noch so generieren, dass du einen Rückgabewert hast.

DelegateTest testObject = new DelegateTest();

foreach (FieldInfo fieldInfo in typeof(DelegateTest).GetFields())
	if (fieldInfo.FieldType.IsSubclassOf(typeof(Delegate)))
	{
		MethodInfo delegateMethodInfo = fieldInfo.FieldType.GetMethod("Invoke");
		Type[] parameterTypes = delegateMethodInfo.GetParameters().Select(pi => pi.ParameterType).ToArray();
		DynamicMethod dynamicMethod = new DynamicMethod("Default",delegateMethodInfo.ReturnType,parameterTypes);
					
		ILGenerator ilGenerator = dynamicMethod.GetILGenerator();
		ilGenerator.Emit(OpCodes.Ldstr,"Methode nicht hinterlegt.");
		ilGenerator.Emit(OpCodes.Newobj,typeof(ArgumentException).GetConstructor(new[] { typeof(string) }));
		ilGenerator.Emit(OpCodes.Throw);
					
		object value = dynamicMethod.CreateDelegate(fieldInfo.FieldType);
		fieldInfo.SetValue(testObject,value);
	}

			
testObject.Test(IntPtr.Zero,IntPtr.Zero,IntPtr.Zero,0);

Ich habs mal für meine Zwecke ausgefüllt, aber da gibts jetzt eine ArgumentException

Welchen Rückgabetyp hat das Feld? Ich tippe mal auf nicht void - und dann gilt die Aussage aus meinem vorherigen Beitrag. Und welchen Typ haben überhaupt deine Delegaten? Mein Beispiel geht nämlich davon aus, dass es Actions sind.

Willst du generell immer eine Exception werfen? Dann gestaltet sich das ganze einfacher.

Bitte gewöhne dir mal an, mit etwas mehr Details aufzuwarten (auch wenn du meinst, sie sind vll. nicht wichtig). Wir haben hier mehrere wichtige Infos erst im Laufe der Diskussion nebenbei erfahren - wenn du die gleich am Anfang erwähnst kann das hier viel schneller gehen. 😃
Zeige uns doch einfach mal etwas mehr Code. Z.B. wie deine Felder deklariert sind (insbes. welchen Typ die haben). Und wie dein Standarddelegat konkret aussehen soll.

Das Problem ist dein OpenOrCreate.
Was du siehst, sind die Reste aus der bestehenden Datei (da der alte Inhalt etwas länger war, als der aktuelle).

Mach stattdessen folgendes:

XmlSerializer xmlSerializer = new XmlSerializer(typeof(Netzstruktur));
using (FileStream fileStream = File.Create(this.Filename))
	xmlSerializer.Serialize(fileStream,this);

Alles von int bis pointern. Bindet wie gesagt auf eine externe Schnittstelle mit unterschiedlichen operationsdefinitionen.

Dann kannst du ja sowieso nicht an ein allgemeines Delegat binden, da du ja noch irgendwelchen Wert zurückgeben musst (es sei denn, du wirfst eine Exception).

Hilft dir die DynamicMethod-Variante weiter?

Da gibt es mehrere Möglichkeiten, sowas auszuwerten. Regex z.B. solltest du ja kennen.
Du kannst ja FormatWith 2.0 - String formatting with named variables - James Newton-King (und noch ein paar andere Möglichkeiten unter Named Formats Redux) als Vorlage nehmen.

Allerdings solltest du dir mehr Gedanken über Probleme machen, die auftreten, wenn Benutzer beliebige SQL-Befehle zusammenbasteln können.

Mir stehen übrigens keine Lambas zur Verfügung, weil ich aus diversen Gründen auf 2.0 Arbeite.

Gut zu wissen... Wie sieht es denn mit den Rückgabetypen der Delegaten aus? Die Frage ist ja auch noch offen.

Hm, spontan fällt mir als Möglichkeit, dynamische Delegaten zu erzeugen, eigentlich nur die DynamicMethod-Klasse (System.Reflection.Emit) ein:

public class DelegateTest
{
	public Action One;
	public Action<string> Two;
	public Action<int> Three;
	public Action<string,int> Four;
}

public static void DefaultAction()
{
	MessageBox.Show("Methode nicht hinterlegt.");
}

...

DelegateTest testObject = new DelegateTest();
MethodInfo defaultActionMethodInfo = typeof(Program).GetMethod("DefaultAction");

foreach (FieldInfo fieldInfo in typeof(DelegateTest).GetFields())
{
	DynamicMethod dynamicMethod = new DynamicMethod("Default",null,fieldInfo.FieldType.GetGenericArguments());

	ILGenerator ilGenerator = dynamicMethod.GetILGenerator();
	ilGenerator.EmitCall(OpCodes.Call,defaultActionMethodInfo,null);
	ilGenerator.Emit(OpCodes.Ret);
				
	object value = dynamicMethod.CreateDelegate(fieldInfo.FieldType);
	fieldInfo.SetValue(testObject,value);
}

testObject.One();
testObject.Two("");
testObject.Three(0);
testObject.Four("",0);

Aber Achtung: Wenn du ein EmitCall auf deine Default-Methode machen willst, muss diese vollständig öffentlich zugreifbar sein. Alternativ könntest du auch direkt den IL-Code z.B. zum Anzeigen einer MessageBox erzeugen.

Gruß,
dN!3L

Floste hat sowas schon gemacht: HTTPSaver

Doch ist tatsächlich eine Exception, wenn ich per [...]
den delegate zur Laufzeit auf die Fehlermethode binde, wobei errorInfo eine MethodenInfo ist.

Das Problem dabei ist, dass die Methodensignatur nicht immer passt. Du musst da einen Delegaten binden, der auch die gleichen Parameter und den gleichen Rückgabetypen hat.

Hier mal ein Beispiel für Delegaten, die nichts zurückgeben:

public class DelegateTest
{
	public Action One;
	public Action<string> Two;
	public Action<int> Three;
	public Action<string,int> Four;
}

...

DelegateTest testObject = new DelegateTest();
Action defaultAction = () => MessageBox.Show("Methode nicht hinterlegt.");

foreach (FieldInfo fieldInfo in typeof(DelegateTest).GetFields())
{
	var parameters = fieldInfo.FieldType.GetGenericArguments() .Select(paramType => Expression.Parameter(paramType)) .ToArray();
	object value = Expression.Lambda(fieldInfo.FieldType, Expression.Call(defaultAction.Method), parameters).Compile();
	fieldInfo.SetValue(testObject,value);
}

testObject.One();
testObject.Two("");
testObject.Three(0);
testObject.Four("",0);

dN!3L

Wir arbeiten gerade an einem Projekt und dazu wollen wir einen Logger der wenn ein Fehler auftritt in eine Datei schreibt die am Webserver liegt.

Da gibt's schon ELMAH (Error Logging Modules and Handlers) für...

Hm, eine Ausnahme mit diesem Text erhält man, wenn die CR-Runtime nicht auf dem Client-Rechner installiert ist (jedenfalls bei VS2010).
Aber du sagst ja, dass die installiert ist und die Assemblies auch alle vorhanden sind... Hast du mal geguckt, ob es ein 32/64bit-Problem sein könnte?

Sind die folgenden Dateien auf dem Zielrechner vorhanden?

Alternativ einfach die XML in ein XmlDocument einlesen und dann mittels XPath (XmlNode.SelectSingleNode) den gewünschten Knoten auslesen.

string version = xmlDocument.SelectSingleNode("/Patches/Patch[@Name='Programm2']/@Version").Value;

Eine gute Übersicht und Anleitung - was es ist und vor allem, was es nicht ist - gibt es auch noch unter Jeff Wilcox – Getting started with code signing for under $100.
Ansonsten schließe mich den Antworten von Maximilian voll und ganz an.

Worauf du außerdem achten solltest, ist die Zertifikatsausstellerkette. Also ob das Root-Zertifikat schon standardmäßig im Betriebssystem vorhanden ist - denn wenn dem nicht so ist, bekommst du weiterhin die "unbekannter Herausgeber"-Meldung.
Es gibt zwar Anbieter, bei denen du Zertifikate sehr kostengünstig oder sogar kostenlos bekommst, aber in der Regel muss man deren Root-Zertifikat erst nachinstallieren (z.B. bei CACert), oder aber es wird von vielen Betriebssystemen/Browsern/etc. akzeptiert, aber eben nicht von allen (afaik zählt StartSSL zu denen).
Relativ sicher, dass das Zertifikat auch als vertrauenswürdig anerkannt wird, sollte man sich bei den großen Anbietern (Thawte, VeriSign, Comodo) sein können - allerdings sind deren Zertifikate üblicherweise relativ teuer (mehrere Hunderter). Jedoch gibt es auch Reseller, die deren Zertifikate sehr günstig anbieten (wir nutzen z.B. K-Software: ab 73$ pro Jahr).

dN!3L

Siehe auch [Tutorial] Keyword-Highlighting (Einfaches Syntax-Highlighting)

Okay das heisst so viel wie es ist praktisch unmöglich. Oder hättest du eine Idee?

Als Dienst ist es wie gesagt aufgrund der Session 0 Isolation in den neueren Windows-Versionen unmöglich.

Du benötigst eine "normale" Anwendung (die z.B. im Autostart gestartet wird), die die Java-Applikation mit Fenster startet. Entweder diese Anwendung übernimmt selbst die Überwachung (und das Starten), oder aber der Überwachungs-Dienst muss mit dieser Anwendung kommunizieren, um die Java-Applikation zu starten.

Aber wiso söll ich keinen Zugriff auf die GUI haben?!

Weil deine Anwendung, die den Prozess startet, ein Dienst ist. In älteren Windows-Versionen ist es ein paar Einstellungen noch möglich, dass ein Dienst eine GUI starten kann; ab Windows Vista laufen Dienste aber komplett in einer anderen Session und haben keinerlei Möglichkeit, Benutzeroberflächen anzuzeigen.

Noch ein Stichwort zum Thema externer Datenbankzugriff und REST: WCF Data Services

Naja, ziemlich allgemein gehalten deine Frage... Dann bekommst du halt eine allgemeine Antwort 😉

Sagt dir Windows Communication Foundation (WCF) was?

Und was ist der Einstiegspunkt in deine DLL? Also welche Methode wird aufgerufen? Gibt es sowas wie eine Main-Methode? Gibt es Parameter?

Momentan sehe ich zwei Möglichkeiten, wie du die Settings aus der *.dll.config-Datei lesen könntest: Entweder, du registrierst einen SettingsProvider, der das macht, oder du verlagerst die Ausführung in eine neue AppDomain, der du den anderen Config-Pfad übergibst.

Ich habe nämlich eine Delphi/C++ Anwendung und diese ruft meine C# dll auf.

Wie genau wird die C#-DLL aus der nativen Anwendung aufgerufen?
Was gibt in deiner DLL ein Assembly.GetExecutingAssembly().Location zurück?

Ich erstelle doch aber nur eine *.dll die ich in ein anderes Programm einspiele. Und wenn ich im Visual Studio so ein Property anlege wird mir automatisch zur DLL die *.dll.config datei generiert.

Soweit alles richtig. Die wirklich von der Anwendung genutzte Einstellungsdatei ist allerdings einzig und allein die *.exe.config - eine Anwendung, eine einzige dazugehörige Config-Datei. Alle anderen *.config-Dateien interessieren die ausgeführte Anwendung nicht. (Es sei denn, du lädst die *.dll.config selbst über die ConfigurationManager API.)

Die *.dll.config-Datei kannst du verwenden, um einfach die Werte in die Einstellungsdatei der eigentlichen Anwendung zu kopieren.

projektname.dll.config

Die Einstellungen müssen in der config-Datei der ausführenden Assembly geändert werden (also die *.exe.config). Nur die dort eingestellten Einstellungen werden verwendet. Wenn eine Einstellung nicht gefunden wird, wird der Standardwert verwendet (der fest in die Assembly einkompiliert ist).

Das heißt, dass Änderungen in der *.dll.config zur Laufzeit nicht beachtet - geschweige denn überhaupt ausgelesen - werden. Du musst sämtliche Werte daraus mit in die Config-Datei der ausgeführten Assembly übernehmen.

Bei Generics kannst du Typeinschränkungen angeben. Du willst allerdings eine Einschränkung auf ein bestimmtes Attribut eines Typs. Das geht nicht - dir wird nichts anderes bleiben, als (erst) beim Aufruf der Methode den Parametertypen auf die Gültigkeit zu prüfen.

Mithilfe der ExpressionVisitor-Klasse* kannst du vorhandene Expressions überarbeiten. LINQ-Kit funktioniert auf die gleiche Weise.

Um alle äußeren Variablen aufzulösen und in Konstanten umzuwandeln, kannst du folgendes machen:

public class CapturedVariableVisitor : ExpressionVisitor
{
	protected override Expression VisitMember(MemberExpression me)
	{
		Expression result = base.VisitMember(me);
		MemberExpression memberExpression = result as MemberExpression;

		if (memberExpression!=null && this.IsCapturedVariable(memberExpression))
		{
			Delegate memberDelegate = Expression.Lambda(memberExpression).Compile();
			object value = memberDelegate.DynamicInvoke();
			return Expression.Constant(value,memberExpression.Type);
		}

		return result;
	}

	private bool IsCapturedVariable(MemberExpression input)
	{
		return (input!=null && input.Member is FieldInfo && input.Member.ReflectedType.IsNestedPrivate && input.Member.ReflectedType.Name.StartsWith("<>"));
	}
}

Aufruf dann wie folgt:

var compareTo = "Maier";
Expression<Func<PersonEntity, bool>> lambda = (p => p.LastName == compareTo);

CapturedVariableVisitor vistor = new CapturedVariableVisitor ();
lambda = (Expression<Func<PersonEntity, bool>>)visitor.Visit(lambda);

Gruß,
dN!3L

*die Klasse gibt es zwar schon im .NET-Framework 3.5, ist allerdings erst ab 4.0 öffentlich zugreifbar. Für die Nutzung in 3.5 ist eine Implementierung unter LINQ: Building an IQueryable Provider - Part II verfügbar.

für adhoc Abfragen über Entity Framework verwende ich Lambda Ausdrücke.

Gehört das manuelle Erstellen von Expressions mit zu deinen adhoc-Abfragen oder hast du die komplett nur zur Veranschaulichung gepostet?

Guck dir mal LINQKit an. Da kannst du variable Expressions als Parameter in Queries auflösen lassen.

Weiss jemand etwas über das geplante Release Date von Visual Studio 11 ? Scheint ja nichts offizielles zu geben. Die Schätzungen schwanken zwischen Q2 und Q4 2012.

Ich habe mal was von wegen "zur TechEd" gehört. Und die ist im Juni.

Laufen Applikationen, die mit VS 11 erstellt wurden, auf Windows XP ?
Welches Framework muss ich dann wählen ? 3.5 ? Oder geht auch 4.5 ?

Du kannst/musst nach wie vor zwischen VS-Version und der Zielplattform unterscheiden. Die Zielplattformen beginnen weiterhin bei .NET 2.0.

Ich würde erwarten, dass 4.5-Anwendungen unter der gleichen Runtime wie 4.0-Anwendungen laufen, also sollten die auch ab Windows XP SP3 lauffähig sein. Die Systemanforderungen für die 4.5 Beta meinen allerdings mind. Windows 7.

Das nächste Treffen findet am Donnerstag, den 05.04.2012, ab 18.30 Uhr statt.

[B]SQL Injection[/B]

Viele Applikationen setzen im Backend Datenbanken ein, um Informationen dauerhaft abzulegen, und besitzen im Frontend u.a. Textboxen für die Eingabe von z.B. Login-Daten oder Suchbegriffen. Aus diesen Eingaben werden anschließend dynamisch Datenbankanfragen generiert. Genau an dieser Stelle ist die Applikation durch SQL-Injections verwundbar, sofern keine entsprechenden Maßnahmen getroffen werden. Welche Gefahren konkret bestehen und wie man diesen unter .NET begegnen kann, wird in diesem Vortrag anhand einer Beispielapplikation demonstriert.

Referent: [i]Ralph Lobe[/i]

Eine Anmeldung für die Brötchen- und Getränke-Planung ist unbedingt erforderlich. Die Anzahl der Teilnehmer ist auf 25 Personen begrenzt. Auf der Anmeldeseite wird auch angezeigt, wie viele Plätze noch frei sind.

Die Kosten des Abends werden wir mit voraussichtlich 7,- EUR wie gewöhnlich auf die Teilnehmer umlegen.

Veranstaltungsort:
BBT Group GmbH, Bernburger Str. 30/31, 10963 Berlin

www.dotnetbb.de

Gerade beim Suchen nach was ähnlichem drüber gestolpert...
Ich hatte das bei meinem OwnerDrawText im TreeView auch (kurz nach dem Erweitern eines Knotens, dann wurde es wieder überzeichnet).
Grund für das Zeichnen in der oberen linken Ecke war, dass e.Node.Bounds.Width/Height 0 war (bzw. e.Node.Bounds.X/Y war -1). Wenn man in diesem Fall einfach nichts zeichnet, ist der Effekt nicht mehr zu beobachten.

Du hast als Rückgabe keine Elemente vom Typ Productdatabase.Models.Category, sondern - wie die Fehlermeldung schon sagt - einen anonymen Typen.

Also entweder musst du im Controller deine Query so anpassen, dass Elemente vom Typ "Category" zurückgegeben werden, oder du musst im View mit dynamic arbeiten, damit du auf anonyme Typen zugreifen kannst.

Ich habe mir überlegt, die Fragen und Antworten dynamisch im Programm in eine XML datei schreiben zu lassen. Die Fragen werden dann geparst sowie die Antworten.

Das Schreiben/Einlesen musst du nicht mal selbst übernehmen. Du schreibst einfach deine Klassen für die Fragen & Antworten und lässt das .NET-Framework den Rest übernehmen. Stichwort XmlSerializer. Um das Speicherformat brauchst du dir da eigentlich keine Gedanken machen; Alternativen wären z.B. auch BinaryFormatter (binäres Speicherformat) oder JavaScriptSerializer (JSON). Oder aber du verwendest - wie schon genannt - eine Desktop-Datenbank (siehe z.B. Empfehlungen für SQL-Datenbank gesucht).

Und, wie mach ich den Member readonly? Geht das über readonly?
Dadurch dass das Feld public ist, hat man ja eigentlich alle Möglichkeiten.

Wie dir schon mehrfach gesagt wurde: Felder macht man nicht public. Dafür verwendet man Properties. Und da kannst du ganz einfach den Setter private machen. Ich weiß gar nicht, warum du hier die ganze Zeit auf deinen Feldern beharrst und keine Properties nehmen möchtest...
Außerdem passen Felder nicht zu deiner folgenden Frage:

Was mach ich jetzt aber, wenn ich das Binding erst beim get Zugriff machen möchte?
Gibt es eine Möglichkeit einen getter zur Laufzeit zu erstellen - oder ist der einzige Weg über eine Wrapper Klasse, die das für mich macht?

Da kommt es drauf an, wie viel du in den Getter schreiben möchtest (oder eben nicht schreiben möchtest). Eine Möglichkeit wäre beispielsweise es äquivalent zu [Artikel] Attribute zur Prüfung von Properties verwenden zu machen. Wenn du gar nichts selbst in den Getter schreiben möchtest, könntest du das automatisch zu Laufzeit mit IL-Emit generieren lassen (da braucht du aber einiges an Fachwissen).

Eine weitere Alternative wäre ein T4-Template, dass dir den entsprechenden Code (vor der Compilezeit) generiert (siehe z.B. T4 (Text Template Transformation Toolkit) Code Generation)

Etwas mehr Kontext bitte. Reden wir hier von Office-Interop? Exchange Web Services? Etc?

Bekommt der User irgendwie mit, dass das Zertifikat abgelaufen ist?

Ausschlaggebend ist der Zeitpunkt der Signierung. D.h. einmal signierte Anwendungen werden auch nach Ablaufdatum des CodeSigning-Zertifikats als vertrauenswürdig erkannt. Das abgelaufene Zertifikat kannst du dann aber nicht mehr zum Neusignieren verwenden.

Das Angebot von GlobalSign ist aber relativ günstig.

Welches? Soweit ich gesehen habe, kosten die CodeSigning-Zertifikate ca. $130/Jahr. Da gibt's günstigere Angebote.

Wir haben ein CodeSigning-Zertifikat von K-Software. Die sind Reseller von Comodo und sollte somit überall ohne Probleme als vertrauenswürdig erkannt werden. Die $90/Jahr finde ich nicht sonderlich viel - zumal du damit meiner Meinung nach z.B. beim Setup einen deutlich professionelleren Eindruck machst.

Standardschriftart des dgv.

Allerdings haben sich die Standardschriftarten von WinXP (MS Sans Serif) zu Win7 (Segoe UI) geändert. Manche Controls nehmen direkt die Standardschriftart aus dem Betriebssystem (z.B. ComboBox), manche die vom Parent-Control (z.B. Label).

Mach doch mal einen Screenshot für uns.

Du könntest auch pro Priorität eine separate Queue erstellen und erst die höchstpriorisierte abarbeiten und dann die nächst niedrigere usw.

Bitte beachte [Hinweis] Wie poste ich richtig? Punkt 6.1 (Bilder als Dateianhang hochladen)

Schreibe die Attribute so, wie du dir das gedacht hast, und laufe dann im Konstruktor einfach mittels Reflection alle Member durch und befülle diese. Da sehe ich jetzt keine großen Schwierigkeiten...
Wie das geht, siehe z.B. [Artikel] Reflection und Metaprogrammierung

Pseudocode:

public class OptionDialog
{
	 public static OptionDialog()
	 {
	 	 foreach (FieldInfo fieldInfo in typeof(OptionDialog).GetFields(BindingFlags.Public|BindingFlags.Static))	 
	 	 {
			PathAttribute pathAttribute = fieldInfo.GetCustomAttributes(typeof(PathAttribute)).SingleOrDefault();
			if (pathAttribute!=null)
			{
			   Form form = RanorexHelper.FindSingleRanorexObject<Form>(pathAttribute.Path);
				fieldInfo.SetValue(null,form);
			}
	 	 }
	 }

   [Path="/form[@processname='application_x' and (@title=Options')]"]
   public static Form Dialog;
}

Evtl. musst du noch den FindSingleRanorexObject-Aufruf etwas anpassen, wenn du nicht immer Forms zurückbekommst.

Gruß,
dN!3L

Wie gesagt - der XmlReader muss eh die Unterebenen durchlesen. Du müsstest dir dann halt merken, in welcher Ebene du gerade bist und dann die Prüfungen nur für die oberste Ebene ausführen.

Hast du mal ReadToNextSibling ausprobiert?

Ansonsten lässt sich dein Vorhaben sehr leicht mittels XPath lösen (XmlDocument.SelectNodes(String)).

Aus Performance-Gründen soll er das nicht machen, da mein zu suchendes Element am Ende stehen kann und er zwischenzeitlich nicht alle möglichen Unterebenen durchlaufen soll. Meine Datei kann zich Tausend Unterebenenen haben und da könnte es Ewig dauern bis er durch ist.

Der XML-Reader muss eh alles sequentiell durchgehen. Da wird es keinen (merklichen) Performanzunterschied geben.
Die XPath/XmlDocument-Variante könnte allerdings bei großen XML-Dateien merklich inperformant werden.

OK, wenn du einen zusammengesetzten Wert anzeigen möchtest, kannst du das nicht so leicht mit dem DisplayMember machen. Da müsstest du dann schon in der DataTable eine (einzige) Spalte haben, die als Anzeigewert verwendet werden soll.

Da ist deine Lösung mit dem Items.Add am praktikabelsten (sofern du vor dem Neubefüllen die alten Elemente entfernst 😃 ).

Ist auch kein Wunder, wenn du bei jedem DropDown die Items neu hinzufügst. Du solltest also vorher noch ein comboBox1.Items.Clear() machen.

Viel eleganter ist es allerdings, wenn du einfach die DataTable als DataSource zuweist und dann DisplayMember (und ValueMember) entsprechend setzt.

Oder mittels Geraetedaten obj = context.Geraetedaten.SingleOrDefault(c => c.ID == GeraeteId);