Forenbeiträge von Fabian Ingesamt 1.985 Beiträge
Hallo JustTom,
dazu hat Josh Smith einen guten Artikel veröffentlicht: http://joshsmithonwpf.wordpress.com/2007/05/05/binding-a-treeview-to-a-dataset/
Der sollte Dir helfen.
Gruß,
Fabian
Hallo Xqgene,
genau das dachte ich auch. Ich hatte auch schon mal in der ImageLibrary von VS2008 gesucht, aber leider nichts gefunden.
Ich bin allerdings gerade bei VS2005 fündig geworden. Unter "VS2005ImageLibrary\bitmaps\outline" kann man die Bilder finden.
Gruß,
Fabian
Hallo zusammen,
ich bin zurzeit auf der Suche nach den Icons, die in der VisualStudio Toolbox vor den Steuerelementen zu finden sind. Ich benötige die für ein eigenes TreeView, um den Typ eines Eintrags besser identifizieren zu können.
Weiß jemand, wo man die bekommen kann? Ich meine, ich hätte sie mal in irgendeinem Icon-Paket von Microsoft gesehen, finde das aber leider nicht wieder.
Edit: Möp, falsches Forum 😦. Bitte verschieben.
Gruß,
Fabian
Hallo JustTom,
ich habe hier gerade etwas vom ATC Avalon Team gefunden: http://blogs.msdn.com/atc_avalon_team/archive/2006/03/01/541206.aspx
Das könnte Dir weiterhelfen. Allerdings wundere ich mich, warum das TreeView und das TreeViewItem abgeleitet werden. Das sollte meiner Meinung nach auch über reines XAML gehen. Da bin ich mir allerdings nicht sicher.
Gruß,
Fabian
Hallo herbivore,
Du hast Recht, Interfaces könnten hier den Aufruf und den Umgang mit den Klassen noch mal etwas erleichtern. Vielen Dank für den Tipp!
Gruß,
Fabian
Hallo zusammen,
langer Titel, aber mir viel nichts kürzeres ein 🙂.
Ich generiere aus einer Datenstruktur den Aufbau eines Fensters. In der Datenstruktur befinden sich alle Kontrollelemente in einer Hierarchie.
Ich möchte jetzt gerne Hilfslinien zeichnen, die dem Designer von Visual Studio ähnlich sind. Dazu muss ich wissen, welche Controls sich um ein bestimmtes Control herum befinden (das bestimmte finde ich beispielsweise durch ein MouseHover oder ähnlichem heraus). Jetzt überlege ich, wie ich am besten die Informationen ablege, wo sich ein Control auf der Form befindet. Ich würde ungern einfach alle Controls absuchen. Das ist bei größeren Forms nicht wirklich effizient.
Habt ihr Erfahrungen damit, wie man so etwas am besten speichert?
Gruß,
Fabian
Hallo zusammen,
DisplayMemberBinding="{Binding Path=AccessKey}"
hach, ich mag das WPF DataBinding.
Gruß,
Fabian
Hallo zusammen,
ich habe mir ein eigenes ComboBoxItem erstellt, damit ein Item noch mehr Informationen aufnehmen kann, welche ich nicht einfach im Tag-Property unterbringen wollte.
Jetzt habe ich allerdings das Problem, dass ich kein Item mehr vorselektieren kann. Früher reichte es, die beiden Interfaces IComparable und IComparer zu implementieren. Das hilft hier aber nicht. Was muss ich beachten, damit ich Items in der ComboBox wieder mit .SelectedText selektieren kann?
Gruß,
Fabian
Hallo zusammen,
zwischen der ganzen Diskussion über Zufallszahlen möchte ich den drei Gewinnern der T-Shirts gratulieren: Herzlichen Glückwunsch!
Gruß,
Fabian
Hallo herbivore,
die Idee ist nicht schlecht. Allerdings handelt es sich nicht um Patterns. Genau genommen bildet jede der 17 Klassen ein Kontrollelement (Button, Label, TreeView, TextBox etc. pp.) ab, die ich mittels WPF und der UI-Automation aus einem vorhandenen Fenster ermitteln kann.
Ein Button kann dann beispielsweise das Invoke- und, je nach Status, das TogglePattern unterstützen. Eine TextBox unterstützt beispielsweise das Text- und das ValuePattern.
Das wollte ich so gut wie möglich abbilden und bin jetzt meiner und norman_timos Idee der Aggregation gefolgt. Das klappt auch sehr gut.
Gruß,
Fabian
Hallo meldano,
da ich die Komponente nicht kenne, einfach mal ein Schuss ins Blaue: Schließt Du das geöffnete PDF, bevor die Anwendung beendet wird? Hört sich danach an, weil Du geschrieben hast, dass der Fehler nur auftritt, wenn Du ein PDF geöffnet hast.
Gruß,
Fabian
Hallo herbivore,
vielen Dank für das Aufbewahren. Hätte nicht gedacht, dass ich dabei bin 🙂. Sieht bei allen ziemlich cool aus.
Gruß,
Fabian
Hallo JuyJuka,
genau das war mein Problem, dass ich keine einheitlichen Methoden in den Patterns habe. Ich werde noch mal drüber nachdenken, ob Deine Variante etwas für mich ist.
Vielen Dank an Euch zwei für die Denkanstöße bzw. Bestätigungen, dass ich doch gar nicht so schlecht lag.
Gruß,
Fabian
Hallo norman_timo,
genau in diese Richtung gingen meine bisherigen Ideen und Lösungsansätze auch. Die Patterns sind schon in eigenen Klassen gekapselt, die bei Bedarf von den Unterklassen verwendet werden. Ich dachte nur, dass es vielleicht noch besser geht.
Hallo JuyJuka,
so ganz kann ich noch nicht durchblicken, wie mir das weiterhelfen kann. Evtl. habe ich mich auch nicht ganz korrekt ausgedrückt: Das Problem an der Sache ist, dass jedes Pattern andere Methoden zur Verfügung stellt. Da ist leider keine "MethodeA", die von jedem Pattern implementiert wird. Die machen alle ganz unterschiedliche Dinge. Oder habe ich Deinen Lösungsansatz nur nicht wirklich verstanden?
Gruß,
Fabian
Hallo Piper,
muss es denn ein MDI-Container sein? So wie Du das beschreibst, benutzt ihr die Möglichkeiten von MDI eh nicht so wirklich, oder habe ich da etwas überlesen? Ansonsten würde ich das einfach statisch auf einem Panel nachbilden.
Generell ist es meiner Meinung nach allerdings eine schlechte Angewohnheit, Dinge aus älteren Softwaresystem einfach in neue zu übernehmen. Gerade wenn sich eine GUI-Technologie weiterentwickelt hat, gibt es oftmals bessere Möglichkeiten, etwas umzusetzen. Wäre etwas wie das VisualStudio Layout vielleicht was für Dich?
Gruß,
Fabian
Hallo zusammen,
ich habe da mal eine Frage an Euch und bitte um Vorschläge aller Art, in welche Richtung sie auch immer gehen mögen.
Ich habe eine Basisklasse, die diverse allgemeingültige Dinge enthält. Davon erben ca. 17 weitere Klassen, die etwas konkreteres repräsentieren. Soweit nichts ungewöhnliches. Jetzt können diese 17 konkreten Klassen bestimmte Verhalten haben, sogenannte Patterns. Es gibt ca. 25 Patterns. Mal kann eine Klasse eins, mal mehrere unterstützen (eins aber mindestens). Welche Klasse welche Patterns unterstützt, weiß natürlich nur die konkrete Implementierung.
Meine Frage ist jetzt, wie implementiere ich das am besten? Ich könnte einfach alles in die Basisklasse packen und die Patterns beispielsweise in Klassenvariablen speichern. Einige Variablen wäre dann halt leer. Die zweite Möglichkeit wäre, die Implementation der Patterns in die Unterklassen zu verschieben. Um dann Code zu sparen, könnte man die Patterns wieder in Klassen kapseln, um identischen Code zu vermeiden (ein Pattern wird eben von mehreren konkreten Implementierungen unterstützt). Die erste Variante sagt mir nicht so zu, da mir das irgendwie wiederstrebt, einfach alles in die Basisklasse zu packen.
Ich hatte auch schon an das Strategy-Pattern gedacht. Leider ist es eben so, dass mehrere Patterns von einer konkreten Klasse unterstützt werden können. Wäre es immer nur eins, wäre das glaube ich schon ein guer Ansatz.
Denke ich da gerade etwas zu kompliziert? Gibt es noch mehr Möglichkeiten, an die ich gerade nicht gedacht habe? Vielleicht kann mich ja jemand in eine andere Richtung schubsen oder mich auch einfach nur in einer möglichen Variante bestätigen 🙂.
Gruß,
Fabian
Hallo zusammen,
ich würde gerne die Nachrichten eines anderen Fensters in meiner WPF-Applikation mitbekommen. Das Handle des Fensters habe ich. Ich weiß nur nicht, wie ich mich in die Nachrichtenschleife einhänge. Konkret geht es in diesem Fall darum, herauszufinden, ob sich der ReadOnly-Status eines Controls geändert hat. Es würde auch reichen, die Nachrichten eines Controls zu bekommen. Das ist wahrscheinlich schon viel selektiver und reicht wahrscheinlich aus.
Gruß,
Fabian
Hallo salla,
ok, wenn Du mehr Kompfort willst, hilft Dir mein Vorschlag auch nicht weiter. Hast Du schon mal bei www.codeproject.com gesucht? Wie GMLOD schon sagte, gibt es schon viele fertige Implementationen für das Problem.
@ErfinderDesRades: Tze tze tze... noch nicht ganz wach? 😉
Gruß,
Fabian
Hallo zusammen,
danke für die Antworten.
@norman_timo: Könnte funktionieren. Ich finde allerdings keine Infos über GetControlFromHandle().
@JAck30lena: Die Vorgehensweise funktioniert nur für Controls, die direkt über System.Windows.Forms erstellt wurden. Ich habe allerdings ein beliebiges Win32-Control.
Gruß,
Fabian
Hallo zusammen,
die Infos, die beispielsweise Spy++ über ein Control herausfinden kann, kennen sicher viele. Ich habe mir jetzt die Frage gestellt, ob man an noch mehr Infos kommen kann. Wie sieht es mit der Schriftfarbe und -art aus? Gibt es Möglichkeit, auch an solche oder generell an noch weitere Infos zu kommen?
Gruß,
Fabian
Hallo salla,
doch, diese Möglichkeit gibt es. Es gibt die Eigenschaft "ShowCheckBox", die bei true eine CheckBox anzeigt. Darüber kann gesteuert werden, ob ein Wert eingegeben wurde oder nicht (CheckBox angehakt oder nicht). Das kann man dann mittels der Eigenschaft "Checked" überprüfen.
Gruß,
Fabian
Hallo zusammen,
ich schließe mich meinen beiden Vorredner an. Ich hasse diese Fragen bzw. diese Shows im Fernsehen normalerweise auch, denke aber auch, dass das hier eine andere Situation ist.
Was ich allerdings mal wieder "erschreckend" finde, ist die Tatsache, dass selbst bei einem Gewinnspiel gerade einmal 62 Leute mitgemacht haben (bis jetzt zumindest). Bei der mittlerweile recht großen Anzahl von Usern ein verschwindend geringer Teil.
Gruß,
Fabian
Hallo S.R.,
ich habe über Google gerade folgendes gefunden: http://bytes.com/forum/thread387572.html.
Ist zwar in VB.NET, sollte Dir aber trotzdem zeigen, wie man es macht. In dem Beispiel werden drei Win32-Funktionen aufgerufen.
Gruß,
Fabian
Hallo blutiger_anfänger,
zum Thema Vollbild: Es sollte gehen, wenn Du die Form auf Maximized hast und den Border auf "None" stellst. Dann sollte alles überdeckt sein (auch eine noch vorhandene Taskleiste).
Gruß,
Fabian
Hallo zusammen,
Herzlichen Glückwunsch und alles, alles Gute, ein großes DANKE an das ganze Team und für die viele, viele Arbeit, die Ihr hier reinsteckt 🙂
dem kann man sich einfach nur anschließen! Auch von mir ein großes DANKE an das ganze Team. Auf das die Community noch sehr lange besteht!
Gruß,
Fabian
Hallo LordVader,
wenn das Definieren von ein paar Zeilen XAML schon overkill ist, kannst Du ja froh sein, WPF zu verwenden. Bei WinForms 2.0 hättest Du dann richtig Spaß.
Gruß,
Fabian
Hallo zusammen,
ich benutze AvalonDock zwar noch nicht ganz so lange, kann es aber bisher absolut empfehlen. Das als kleiner Hinweis an alle, die auf diesen Thread aufmerksam werden und sich vielleicht nicht sicher sind, ob AvalonDock das Richtige für Sie ist.
Angucken sollte man es sich auf jeden Fall.
Gruß,
Fabian
Hallo LordVader,
im Designer WPF Blog ist dazu ein Artikel erschienen, wenn ich mich recht erinnere. Der Link hier sollte Dir weiterhelfen: http://www.designerwpf.com/styling-the-combobox/.
Gruß,
Fabian
Hallo zusammen,
es gibt natürlich doch einen Weg, den man aber erstmal wissen muss. Auch hier die Lösung für alle, die vor dem gleichen Problem stehen:
ControlType currentControlType = null;
object controlTypeNoDefault = automationElement.GetCurrentPropertyValue(AutomationElement.ControlTypeProperty);
currentControlType = controlTypeNoDefault as ControlType;
if (currentControlType == ControlType.Window) {
[...]
} else if [...]
Gruß,
Fabian
Hallo nikk126,
hulkstar hat Dir schon den richtigen Begriff genannt. Wenn es eine Eigenschaft im Player gibt, die beim Fortschritt immer erhöht wird, sollte diese Eigenschaft an den Slider gebunden werden können. Dann kannst Du Dir den Timer sparen.
Gruß,
Fabian
Hallo zusammen,
für alle, die das gleiche Problem haben, hier die Lösung aus dem MSDN WPF Forum, in dem ich auch gefragt habe:
Canvas canvas = new Canvas();
Slider slider = new Slider();
ScaleTransform scaleTransform = new ScaleTransform();
canvas.RenderTransform = scaleTransform;
BindingOperations.SetBinding(scaleTransform, ScaleTransform.ScaleXProperty, new Binding("Value") { Source = slider });
BindingOperations.SetBinding(scaleTransform, ScaleTransform.ScaleYProperty, new Binding("Value") { Source = slider });
Gruß,
Fabian
Hallo zusammen,
im Moment versuche ich, zuverlässig die Größe der NonClientArea eines Fensters zu ermitteln. Mir geht es hauptsächlich um die Caption eines Fensters. Bis jetzt habe ich es über die Angaben der GetSystemMetrics Funktion gemacht, aus der ich die Größe auslesen kann. Gibt es evtl. noch andere Möglichkeiten, das direkt über ein Window-Handle herauszubekommen?
Gruß,
Fabian
Hallo Chronox,
das sieht sehr gut aus. Geht sogar noch über das hinaus, was ich brauche, da ich zwar nicht die Anzahl der Spalten weiß, die aber pro ListView immer gleich sind. Es ist also keine wirklich verschachtelte Collection.
Mit Deinem Beispiel müsste ich aber trotzdem viel anfangen können. Vielen Dank schon mal dafür!
Gruß,
Fabian
Hallo zusammen,
im Moment erhalte ich eine List<List<string>> Collection, die ich gerne einfach mittels zwei foreach-Schleifen durchlaufen möchte. Jede Collection auf oberster ebene ist eine Reihe in der ListView. Die Einträge in der zweiten Collection dann die eigentlichen Einträge in den Spalten einer Zeile. Ich versuche gerade verzweifelt, die ListViewItems im Code zu erzeugen. Wie gehe ich da denn im Code vor? Eine einfache Items-Eigenschaft gibt es ja nicht mehr.
Die zweite Frage, die mich interessiert, ist, ob ich das Ganze besser mittels DataBinding lösen sollte. Ich weiß allerdings nicht, wie ich das Template oder die Klassen dafür gestalten soll. Bisher habe ich nur mit einer festen Anzahl von Spalten gearbeitet und die dann einfach an entsprechende Eigenschaften der Business-Klassen gebunden. Ich weiß allerdings vorher noch nicht, wie viele Spalten es sind. Vielleicht kann mir hier jemand ein Tipp geben, wie ich das trotzdem mittels DataBinding realisieren kann. Ich denke, der Weg ist bei WPF im Normalfall zu bevorzugen.
Die eigentliche Bindung muss im Code geschehen. Ein grundsätzliches Template kann ich in XAML zur Verfügung stellen, da dass fest sein kann, die Anzahl der Spalten natürlich wieder nicht.
Gruß,
Fabian
Hallo Martin123,
eine sehr gute Erklärung dazu findest Du auf www.codeproject.com und im speziellen auf http://www.codeproject.com/KB/WPF/WPFDiagramDesigner_Part1.aspx. Allerdings nur in englischer Sprache.
Das Tutorial heißt Diagram Designer und hat, soweit ich weiß, momentan vier Teile. Da wird alles erklärt, von Selektion, über Drag&Drop bis hin zu verbinden von Elementen.
Gruß,
Fabian
Hallo talla,
danke für Deine Antwort. Allerdings besitzt die ScaleTransform keine Methode SetBinding(). In etwa die gleiche Richtung hatte ich auch schon gedacht. Das Problem hat sich allerdings in der Zwischenzeit etwas geändert:
Ich habe ein Canvas, dass ich durch das ScaleTransform zoomen möchte. Das Canvas-Objekt wird zur Laufzeit erstellt (und einem ScrollViewer hinzugefügt), der Slider existiert schon im XAML-Code. Diese beiden möchte ich jetzt wie oben beschrieben binden. Vielleicht hast Du ja auch dazu eine Idee.
Gruß,
Fabian
Hallo knatterton,
danke für Deine Antwort. Allerdings meine ich nicht, die Skalierung selbst zu programmieren. Das habe ich gar nicht vor. Ich möchte wirklich nur die Bindung im Code erzeugen, also etwas wie:
Binding binding = new Binding(...);
Ich möchte das Equivalent zum obigen XAML-Code in C# haben, da ich das Ganze zur Laufzeit binden muss.
Gruß,
Fabian
Hallo zusammen,
ich versuche gerade ein Binding im Code zu erstellen. Unter XAML überhaupt kein Problem:
<Slider Name="ZoomSlider" Value="1" Maximum="100" DockPanel.Dock="Bottom" />
<ScrollViewer Name="svMainContent" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto">
<ScrollViewer.LayoutTransform>
<ScaleTransform ScaleX="{Binding ElementName=ZoomSlider, Path=Value}"
ScaleY="{Binding ElementName=ZoomSlider, Path=Value}" />
</ScrollViewer.LayoutTransform>
</ScrollViewer>
Das würde ich jetzt gerne im Code nachbilden, und bin etwas überfragt, was ich als Source angebe und wie ich mich auf das ScaleX der ScaleTransform des ScrollViewers beziehe.
Gruß,
Fabian
Hallo HeinzTomato,
ergänzend möchte ich noch sagen, dass Du auch Dictionaries verwenden kannst. Du kannst beispielsweise in Deinem Hauptfenster ein ResourceDictionary anlegen und dann über MergedResourceDictionaries füllen. Zum Beispiel so:
<Window.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="ausgelagert.xaml" />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Window.Resources>
Gruß,
Fabian
Hallo Tomass,
antürlich wird intern eine Object-Hierarchie aufgebaut, die dem XAML-Code entspricht. Allerdings nicht so, dass man mit Eigenschaften alà Page.TabPage.Reiter etc. pp. auf die Controls zugreifen könnte. Dafür müssten ja durch das Framework automatisch diese Eigenschaften angelegt werden.
Ich denke, Du kommst mit der Find()-Methode recht weit. Die Page-Referenz wirst Du noch übergeben müssen, aber darauf kannst Du dann mit Find() arbeiten.
Gruß,
Fabian
Hallo zusammen,
es scheint wirklich keine andere Möglichkeit zu geben, als die Eigenschaften LocalizedControlType bzw. ClassName zu benutzen. Meistens ist eine Kombination aus beiden (ClassName == "button", LocalizedControlType == "check box" zum Beispiel) der Weg zum Ziel.
Gefällt mir zwar überhaupt nicht, da LocalizedControlType auch übersetzt wird (deutsches Framework, deutsche Bezeichner etc. pp), aber eine andere Möglichkeit habe ich bis jetzt noch nicht gefunden.
Falls jemand doch einen besseren Weg weiß, immer her damit!
Gruß,
Fabian
Hallo zusammen,
Windows-Standard halt - seltsam, dass das für so viele Leute etwas Neues ist.
genau das Gleiche habe ich mir beim Durchlesen der Antworten auch gedacht 🙂. Mich gruselt es, wenn ich drüber nachdenke, ich hätte jedes Mal den Text abgetippt oder Screenshots erstellt 😉.
Aber Dank herbivore wissen es jetzt viele myCSharpler mehr 🙂.
Gruß,
Fabian
Hallo zusammen,
ich befasse mich im Moment mit dem UIAutomation Framework von WPF und bin ganz schön begeistert. Leider findet man nicht wirklich viele Informationen und nun hoffe ich, dass hier jemand schon etwas damit zu tun hatte.
Wie identifiziere ich ein Control denn eindeutig? Ich habe es über LocalizedControlType und ClassName versucht. Ich möchte beispielsweise alle Buttons finden und dann Buttons auf einer anderen Form anlegen. Allerdings bekomme ich auch Treffer bei Controls, die keine Buttons sind. Über ClassName habe ich bis jetzt die besseren Ergebnisse erzielt, aber so ganz zufrieden bin ich noch nicht.
Vielleicht hat ja jemand noch eine Idee.
Gruß,
Fabian
Hallo zusammen,
ich hatte natürlich auch schon dran gedacht, mir die Werte selber zu berechnen. Allerdings bekomme ich dann ordentliche Probleme mit den NonClient Bereich. Dazu zählen ja auch Menüs etc. pp., was alles in die Berechnung mit einfließen müsste.
Deswegen dachte ich mir, könnte ich das evtl. durch eine Win32-Funktion berechnen lassen und mir den ganzen Ärger ersparen. Kann ich aber wahrscheinlich nicht vermeiden.
Gruß,
Fabian
Hallo zusammen,
ich habe die BoundingRectangles von diversen Controls eines Fensters, dass nicht zu meiner Anwendung gehört. Jetzt möchte ich gerne wissen, wo sich das Control relativ zu dem Fenster befindet, zu dem es gehört.
Die Methoden PointFromScreen und PointToScreen fallen ja flach, da damit die Position relativ zum eigenen Fenster berechnet wird. Es ist aber eben ein anderes Fenster.
Versucht habe ich es mit der Win32 Methode ScreenToClient, da ich dort ein Window-Handle angeben kann. Allerdings bekomme ich damit die gleichen Koordinaten zurück geliefert, was ich nicht so ganz verstehe.
Hat vielleicht jemand noch eine Idee, wie ich die Koordinaten der Controls auf ihrem Fenster herausbekomme?
Gruß,
Fabian
Hallo Khalid,
danke für Deine Antwort. Ich habe bei CodeProject eine gute Lösung gefunden: http://www.codeproject.com/KB/graphics/screen_capturing.aspx?df=100&forumid=159109&fr=26
Dort wird es wie bei Spy++ gemacht. Die Solution ist auch in C# geschrieben (natürlich bei Verwendung der darunter liegenden WinAPI für das Herausfinden des Handles etc. pp.).
Darauf kann ich aber sehr gut aufbauen.
Gruß,
Fabian
Hallo zusammen,
ich stehe im Moment vor dem Problem, dass ich den Window-Handle eines beliebigen Fensterns in meiner Anwendung brauche. Ich würde das jetzt gerne ähnlich wie in Spy++ lösen. Einfach auf ein Fenster klicken und den Handle bekommen. Ist so etwas in C# möglich?
Ich hatte schon die Idee über GetProcesses() bzw. über GetProcessByName() zu gehen, allerdings bringt mir das nicht viel, wenn die Anwedung ein MDI-Host ist und ich gerne ein bestimmtes MDI-Child haben möchte.
Vielleicht habt ihr ja noch weitere Ideen.
Gruß,
Fabian
Hallo zusammen,
hier noch ein direkter Link zum Blog-Post von Scott Guthrie, der auf die Änderungen eingeht: http://weblogs.asp.net/scottgu/archive/2008/05/12/visual-studio-2008-and-net-framework-3-5-service-pack-1-beta.aspx
In dem Blog-Post ist der Artikel von Tim Sneath verlinkt, der genauer auf die Änderungen hinsichtlich WPF eingeht: http://blogs.msdn.com/tims/archive/2008/05/12/introducing-the-third-major-release-of-windows-presentation-foundation.aspx
Gruß,
Fabian
Hallo zusammen,
ich habe eine Frage bzgl. dem "Übersetzen" des Transaktionslogs. Unter dem ASA ist es möglich, mittels des Programms "dbtran.exe" das Transaktionslog so zu übersetzen, dass man am Ende eine Textdatei mit den zugehörigen Statements erhält.
Gibt es so etwas auch für den MSSQL? Ich brauche die Möglichkeit, die Statements zu analysieren, ohne ein Programm von Dritten einzusetzen.
Gruß,
Fabian