Es muss doch möglich sein, vorallem da der Context ja static ist, dass ich den nur einmal irgendwo am Programm setzen muss, und der dann an jeden Call angehängt wird??

Um die Frage zu beantworten: Ja, ist möglich.

Aber was genau ist das Problem? Setz die Property einfach beim Programmstart, und gut ist.

Was du suchst ist das params-Keyword.

Ich tippe eher auf ein Problem mit tabellenname (ungültige Zeichen, oder ähnliches) den Quotes, die du für Spaltennamen verwendest. Übrigens würde ich empfehlen, dass du dir mal Parameter in SQL Statements ansiehst.

Sein Problem dürfte wohl eher sein, dass im Insert-Text (innerhalb des quoted Text) ein ' vorkommt.

Eventuell solltest du, anstatt das Insert als String zu bauen, ein Prepared Statement/Command Parameter benutzen.
Je nachdem, wie du das machst, kannst du in Verbindung mit deinem DBA-Layer zur Suchmaschine deines Vertrauens gehen und mehr drüber rausfinden.

Du könntest einerseits an deinem XmlTextWriter die Formatting-Property auf Indented setzen, oder wenn du in 3.5 unterwegs bist könntest du auch System.Xml.Linq benutzen (wo per default indented wird).

Mit WriteStartElement beginnst du einen neuen Tag. Was dein Code tut ist das hier:

<04_41_44/>

Und das ist natürlich nicht zulässig, XML Tags müssen mit einem NameStartChar beginnen (der keine Zahlen erlaubt).

Die Metadatendatei System.Data.Linq.dll konnte nicht gefunden werden.[/error] Klingt als ob die Assembly nicht im Suchpfad vorhanden ist. Im Zweifelsfall versuch den absoluten Pfad einzufügen (zb. per typeof(EntitySet<>).Assembly.Location); so mach ich das bei einem meiner Projekte, wo ich das Assembly selbst hinzufüge, wo die Codegenerierung drin ist.

  
...  
            parameters.ReferencedAssemblies.Add("mscorlib.dll");  
            //parameters.ReferencedAssemblies.Add("System.Data.Linq.dll"); => Fehler  
...  
  

Und welcher Fehler tritt an genau der Stelle auf?

Nachdem du selber schon sagst, dass es hierarchische Daten sind, könnte ein HierarchicalDataTemplate Abhilfe schaffen. Analog zum normalen DataTemplate kannst du damit das Aussehen deiner Objekte festlegen; nur dass es auch Unterelemente beinhalten kann.
In Kombination mit XML-Binding wäre das eventuell eine Möglichkeit für dich.

Benutzt du vom Client aus auch ein BasicHttpBinding (oder je nachdem)? Eventuell hast du dort Security konfiguriert, die du über den Browser (und Serverseitig) natürlich nicht hast.

Das geht auch mit wesentlich kleineren Dateien, muss nur XAML sein 😃

Ich fürchte fast, dass dein Problem VS2010 selbst ist; ist ja leider nicht das schnellste.
Und nachdem du noch auf XP unterwegs bist, ist es auch nicht sonderlich sinnvoll auf [http://blogs.msdn.com/b/visualstudio/archive/2011/08/24/how-we-use-your-perfwatson-data-to-identify-unresponsive-areas.aspx]Perf Watson]() zu verweisen.

Eventuell kannst du mal SP1 versuchen, das hat zumindest bei mir für ein bisschen mehr Stabilität gesorgt; langsam wars aber leider trotzdem.

Graphics.FromHdc bzw. Graphics.FromHwnd wäre das...aber ich glaube, dass du hier eher mit schwerern Geschützen auffahren musst (WndProc in dein eigenes Programm umrouten und entsprechend handhaben usw.)
Eventuell könnte das in .NET sogar über NativeWindow funktionieren (nicht getestet, nur schnell drübergelesen).

Ich denke, du willst auf eine Anonyme Klasse hinaus, die gleichzeitig ein Interface implementiert - was es in C# nicht gibt.
Weil du allerdings von Listenern sprichst; die werden in C# nicht über Klassen/Interfaces gelöst, sondern per Event/Delegate - und die kannst du wiederum anonym (zb. als Lambda-Expression) definieren wie in deinem Beispiel.

Eventuell interessieren dich die Ableitungen von DbConnectionStringBuilder, so zb. SqlConnectionStringBuilder für MSSQL.
GUI dazu musst du aber trotzdem selber bauen 😃

Im Grunde sagt der Fehler aus, dass du denselben Typen im selben Namespace mehrfach in deinem Projekt drinhast.
Die Zeile "...des importierten Typs aus '...bin\Debug\Nachkalkulation.exe'..." lässt mich vermuten, dass du eventuell die exe-Datei selbst als Referenz im Projekt drin hast.

Ist dein Code:

Console.WriteLine(Regex.IsMatch("<FieldInfos/>", "\\bFieldInfo\\b")); //false
Console.WriteLine(Regex.IsMatch("<FieldInfo name=\"test\"/>", "\\bFieldInfo\\b")); //true
Console.WriteLine(Regex.IsMatch("<NotMyFieldInfo />", "\\bFieldInfo\\b")); //false

Fangen wir lieber nochmal von vorne an: Was hast du vor? Willst du alle FieldInfo in einem XML auslesen? Wenn ja: Versuchs mal mit Linq to XML (bzw. eben dem Namespace System.Xml.Linq)

Abgesehen davon, dass es sich hier nicht um WinForms handelt, sondern eher um XML, funktioniert der von dir gepostete Code. Wenn ich das ganze bei mir laufen lasse, wird <FieldInfo something/> korrekt gematcht, nicht aber <FieldInfos> oder SomeFieldInfo.

Wärst du eventuell mit System.Xml bzw. System.Xml.Linq besser bedient?

Nur zur Info: Hexadezimal, Dezimal, Oktal (und was es nicht noch alles gibt) sind nur verschiedene Repräsentationen derselben Daten. Wenn du ein 0x20 (hex) sendest, kommt auf der anderen Seite auch eine 32 (dec = hex 20) an.

Ich vermute, du willst eher einen String versenden, der die einzelnen Bytes als Hexadezimale Werte darstellt:

string input = "whatever"; //"\x77\x68\x61..."
var hex = new StringBuilder();

foreach (char c in input)
  hex.AppendFormat("{0:x}", (int)c);

string hexString = hex.ToString(); //hier steht jetzt 776861... drin
byte[] hexBytes = Encoding.Default.GetBytes(hexString); //hier ist jetzt 55, 55, 54, 56, 54, 49,... drin

Was davon willst du gern haben?

Sollte sich alles in der NHibernate-Dokumentation finden lassen.
Wenn du die Mapping-Dokumente per Hand in XML verfasst, müsste es über den <id/>-Tag funktionieren. Wenn du Fluent-NHibernate verwendest, gibts dafür die Id(x => x.MyPrimaryKeyProperty) Methode.

Mittlerweile habe ich aber immer mehr das Gefühl, das ich wohl gesamt einen falschen Weg beschritten habe um das Problem zu lösen.

So kommts mir auch vor 😃

Gibt es einen triftigen Grund, warum du T als generischen Parameter reingibst (außerdem mit new()-Constraint), und nicht einfach nur auf einer Instanz der Basisklasse arbeitest; mit "normalen" abstract/virtual Methoden?

Irgendwie riecht das ganze nach einer Art O/R-Mapper, Serializer oder so, und dein T.getString() ist eine Art Kennzeichen für die spezifische Subklasse...
Wenn ich hier richtig liege, was spricht gegen typeof(T).FullName (wenn du nicht grade alle paar Wochen deine Klassen/Namespaces umbenennst)?

Ich denke eher, dein Problem fängt schon früher an. Wenn du das "&szlig;" als Text einfügst, wird das & direkt durch &amp; ersetzt - eben weil es ja eine Spezialbedeutung hat und du "Text" einfügst; keine EntityReference. Der Writer nimmt das dann nur 1:1 und schreibt es als &amp; raus.

Ohne DTD (oder entsprechenden Resolver, oder was auch immer man dafür braucht - ich würd selber gern wissen was!) kann weder System.Xml noch System.Xml.Linq mit Character-Entities umgehen - die einzige Ausnahme ist &amp;

Nur kurz am Rande, was spricht gegen eine BindingList oder eine ObservableCollection? Beide sagen dir Bescheid, wenn sich Items geändert haben; somit kann das GUI entsprechend drauf reagieren (über ListChanged bzw. CollectionChanged).
Der Background-Thread fügt einfach jedes Item ein, was er geladen hat, anstatt drauf zu warten bis alles fertig ist (Hinweis: eventuell bekommst du hier auch wieder Probleme beim Zugriff von verschiedenen Threads, dafür kannst du aber die Forensuche benutzen - gab schon genug Beiträge zu den Punkten).
Je nachdem, ob du auf der anderen Seite sogar WPF hast, sollte das ganze auch ohne größere Umbauten automagically funktionieren.

genau um Streaming gehts momentan 😉

Hab ich gemerkt 😃
Mein Post ging eher in die Richtung was man übertragen sollte.
Nachdem er sowohl Datei als auch Diagramm will, wird wohl eins der beiden alle Daten haben, die drin sein sollen - und das würde ich übertragen plus das jeweils andere ableiten.

Spricht was dagegen, das Datenfile am Server zu erzeugen, und das ganze dann per Stream zum Client zu schieben (damit kannst du dir dann auch den Fortschrittsbalken anzeigen lassen, wenn du eine entsprechende Stream-Implementierung verwendest, die dir Statusinformationen usw. liefert)?

Clientseitig generierst du dann basierend auf dem Datenfile dein Diagramm.

Ich bin mir nicht ganz sicher, ob ich das ganze inzwischen auch richtig verstanden habe, aber könnten dir Extension Methoden hier weiterhelfen?

Nachdem sowohl das Interface als auch die 3 Implementierungen nicht von dir sind (in der anderen Programmiersprache innerhalb der Library?), kannst du so oder so nicht auf Implementierungsdetails eingehen - und damit sollte auch eine Extension Methode reichen, die sogesehen ja auch nur Zugriff auf die public Member des erweiternden Interface/Klasse hat.

Nachteil, funktioniert natürlich nur mit Methoden - Extension Properties gibts ja nicht.

Wenn ichs richtig verstanden habe, willst du sowas:

var myInstance = MyClass.CreateObject("info", someTypeInfo)
{
    IntProperty = 42,
    StringProperty = "from object initializer"
};

Was spricht gegen die Verwendung von Lambdas? Du dürftest doch wissen, um welchen Typ es sich handelt bzw. welche Properties der hat.

var myInstance = MyClass.CreateObject("info", someTypeInfo, theNewlyCreatedInstance => 
{
   theNewlyCreatedInstance.IntProperty = 42;
   theNewlyCreatedInstance.StringProperty = "from Action<MyClass>";
});

Der Object-Initializer macht im Hintergrund ja nichts anderes als die einzelnen Property-Zuweisungen - ist ja nur Syntax, die der Compiler drauf umbaut.

Der Vollständigkeit halber möchte ich mal Common.Logging einwerfen, was im Grunde ja genau der Wrapper ist, der hier gefragt ist.

Außerdem: Selbst wenn du den Weg der Expression Trees wählen solltest, musst du wissen dass erst ab .NET 4.0 Blöcke unterstützt werden, bis .NET 3.5 können nur binäre Bäume (sprich deine erste, "fluent" Expression) ausgewertet werden.

Die Frage ist: warum will man das, oder warum interessiert dich welche Notation benutzt wurde?

Mir wäre nicht bekannt, dass die Schema-Klassen im Framework sowas können, (lasse mich aber gerne eines besseren belehren.

var doc = XDocument.Load("master.xsd");
var includes = doc.Root.Descendants(XName.Get("http://xsd/whatever", "import"));
includes.ForEach(i => i.ReplaceWith(LoadIncludedDocument(i.Attribute("href").Value)));

Vorsicht, wenn die Applikation als Dienst läuft (oder auch als anderer Benutzer, als euer aktuell angemeldeter Benutzer) stehen Netzwerklaufwerke möglicherweise nicht zur Verfügung (außer, ihr habt sie selber per Code eingemappt).

Zur Sicherheit per UNC (oder gleich einem lokalen Laufwerk) versuchen; an File.Exists oder eventuell anderen Sachen im Framework wirds nicht liegen dass es nicht funktioniert.

Eventuell hilft dir dieser Blog-Eintrag weiter:
AddressAccessDeniedException: HTTP could not register URL http://+:8080/<…>.

Der Vollständigkeit halber würde ich das Monitor.Exit auch in den finally-Block reinsetzen. Oder was spricht gegen lock(...)?

Ah, sehr gut. Hab das Tool schon mal vor einer Zeit gesehen, und gedacht "hey, wird auch Zeit".
Grade bei uns gibts oft das Problem, dass auf 1:1 identischer Hardware VS2010 mal läuft wie ne eins, mal alle paar Minuten hängt oder sich mal per Random verabschiedet - ohne merkliche Unterschiede in der Konfiguration.

Ich hoffe mal, dass es MS damit auch endlich schafft, die Probleme zu beheben.

Warum machts dann einen Unterschied? Es ist für beide Interfaces dieselbe Methode; was heißt dass es gemäß dem Contract des Interface dasselbe tun sollte.

Wenn dem nicht so ist, solltest du vielleicht überlegen die Interfaces anders aufzuteilen.

...oder hat das Beispiel eigentlich gar nix mit deiner ursprünglichen Frage zu tun, sieht aber bei dir zufällig auch so aus?

Kann es sein, dass du sowas meinst?

interface ICanSave
{
   bool CanSave { get; }
   void Save();
}
interface ICanDelete
{
    bool CanDelete { get; }
    void Delete();
}
class CanDoBoth : ICanSave, ICanDelete
{
   //...
}

Auf einer Instanz der Klasse ist es jetzt möglich, dass aufgrund des Status CanDelete auf true wäre (und du damit Delete aufrufen darfst), aber CanSave auf false ist (und damit kein Save möglich wäre).

...nur, dass es bei dir so aussieht:

interface IValidatable
{
   bool IsValid { get; }
   void DoStuff();
}
interface IOther1 : IValidatable { }
interface IOther2 : IValidatable { }
class CanDoBoth : IOther1, IOther2
{
   //...
}

...und dein IsValid/DoStuff sich je nach angesprochenem Interface anders verhält (indems einmal Other1 und einmal Other2 macht).

Oder?

Fehlermeldung:
System.ComponentModel.Win32Exception: Falscher Parameter bei System.Drawing.Icon.Initialize(Int32 width, Int32 height) bei System.Drawing.......

Handelt es sich um ein Vista Icon (so eins mit PNG drin)?

Genauso, wie dus für Reflection machen würdest. Assembly.LoadFrom und co.

Warum hast du eigentlich das Namensproblem? Die Datei selber kannst du ja theoretisch umbenennen, wie du willst.

Bin mir nicht sicher, obs mit DLLs von gleichem Namen funktioniert, aber an sich sollte es genau dafür in den Properties der Reference das Feld "Aliases" geben. Standardmäßig landet das Ding in global::, kann aber auch wo anders reingeladen werden. Zumindest dürfte das laut extern alias (C# Reference) der empfohlene Weg sein.

node enthält das gleiche Xml wie vorher nur mit lauter Formatierungszeichen
ala "&lt" usw. Die SetValue Funktion haut die irgendwie mit rein.
In der folge schlagen auch Element Abfragen etc. fehl. Warum ist das so bzw.
was habe ich falsch gemacht?

SetValue müsste sich eigentlich so verhalten wie die Property Value; und den textuellen Inhalt wiederspiegeln. Wenn du dort "<text/>" reinschreibst, bekommst du das ganze eben als Text, und nicht als XML.

Irgendwie sieht dein Beispiel auch ein wenig komisch aus...Am Ende dürfte nämlich das hier rauskommen, wenn man die ganzen ToStrings und Parents wegnimmt:

node.ReplaceWith(node);

Was du beschreibst wird oft durch einen zentralen Vermittler gelöst, der allen Komponenten bekannt ist - den sogenannten Mediator.

Wie das ganze jetzt konkret implementiert ist, hängt von den Anforderungen ab.
Bei dir könnte die zentrale Stelle im einfachsten Fall selber der Mediator sein, und beispielsweise eine ShowMessage Methode zur Verfügung stellen.
Die kann im wiederum einfachsten Fall ein Event auslösen, wo sich andere Module (die in der Lage sind, eine Message auszugeben) dranhängen können (oder auch nicht).

Wenn du das ganze in C++ machst, müsste es die übliche Scope-Resolution Notation per :: sein. In C# ist's wie gehabt per .

Tools > Options, Text Editor > XAML > Miscellaneous, Always open documents in full XAML view.

Nur mal so nebenbei, was spricht gegen Directory.GetDirectories mit einem Pattern von ".svn" (oder "?svn", um auch die "_svn"-Sandboxes zu erwischen) und SearchOption.AllDirectories?

Vorsicht, der Standard-Namespace ist im Normalfall der Name des Projekts, nicht der Solution.
Vielleicht kann man hier an den Standard-Templates schrauben; mir ist kein Weg bekannt es umzustellen( - würde ich ehrlich gesagt auch nicht, weil ich im Normalfall ja für genau das verschiedene Projekte mache

element.Attribute("name") != null

...Probieren geht über Studieren, hättest ja auch mal ausprobieren können 😃

Ich würde dir empfehlen, anstelle der String-Operationen die entsprechenden Operatoren der Linq-to-XML Klassen zu benutzen; XName und XNamespace haben einen implicit operator string der von String konvertiert sowie den operator+ der Elemente mit Namespace verketten lässt.

Frage 1: Nein, nicht wirklich. Alternativ könntest du noch string.Split mit ':' benutzen, aber hier ist das auch nicht unbedingt nötig, wenn sich der Präfix nicht ändert.

Frage 2: xmlns-Attribute geben an, ob und in welchem Namespace sich Elemente befinden. "xmlns" ist der Default-Namespace, der für alles ohne Präfix gilt. "xmlns:abc" wäre der Namespace für Elemente mit Präfix "abc:" usw.

Wenn du an das Element kommen willst, müsstest du entweder den Namespace inkludieren:

XNamespace _3dxml = "http://www.3ds.com/xsd/3DXML";
root.Element(_3dxml + "Structure");

bzw.

root.Element(XName.Get("Structure", "http://www.3ds.com/xsd/3DXML"));

Oder du machst die Abfrage über Linq und LocalName:

root.Elements().FirstOrDefault(e => e.Name.LocalName == "Structure");

Wenn du ein Schema hast, kannst du dir eventuell Linq-to-XSD ansehen - der generiert dir stark Typisierte Klassen und lässt dich so zugreifen (könnte man eventuell mit Serialisierung vergleichen, nur dass du vom XML weggehst anstelle von der Klassenhierarchie).

An sich war das ganze als Spielwiese gedacht, was ursprünglich komplett ohne ViewModels auskommt - und zwei XML-Dateien über das XML-Binding miteinander vermanscht.
Aber gut, wird wohl so um einiges schmerzfreier sein - ab ins ViewModel damit.

Das ganze war btw. keinesfalls negativ gemeint, aber ich bin halt einer der Menschen der gerne abseits von Pfaden wandert, und was neues versuchen will.