Erstmal vielen Dank für deine schnelle Antwort. Gibt es eine Möglichkeit herauszubekommen welcher FileShare-Modus beim Schreiben der Datei verwendet wird?

Wenn ich das jetzt richtig verstanden habe, starte ich, wenn eine Datei erstellt wurde, einen neuen Thread in dem ich "zyklisch" die Datei öffne und auslese und dabei immer wieder einen Sleep durchführe?

Hallo,

ich habe einen FileSystemWatcher auf einen Ordner, z.B. C:\Temp.
Für diesen gibt es ein onCreated Event:

fw.Created += new FileSystemEventHandler(onCreated);

In dem Event soll die angelegte Datei ausgelesen werden. Ich hab bisher schon verschiedene Variante ausprobiert, bisher sind alle in einer IOException geendet.
Die Fehlermeldung sieht so aus:> Fehlermeldung:

"MyProject.vshost.exe" (Verwaltet (v4.0.30319)): "F:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\mscorlib.resources\v4.0_4.0.0.0_de_b77a5c561934e089\mscorlib.resources.dll" geladen
Eine Ausnahme (erste Chance) des Typs "System.IO.IOException" ist in mscorlib.dll aufgetreten.

Die onCreated sieht so aus:

void onCreated(object sender, FileSystemEventArgs e)
{
      StreamReader sr = new StreamReader(e.FullPath);
      Console.WriteLine(sr.ReadLine());
      sr.Close();
}

Das Kuriose, beim ersten Aufruf des Events funktionierts "häufig" (nicht immer!), wird das Event dann jedoch erneut aufgerufen kommt die Exception.

Wenn der Code im try-Block steht und ich die Exception fange, dann kommt die Exception:> Fehlermeldung:

Eine Ausnahme (erste Chance) des Typs "System.IO.IOException" ist in mscorlib.dll aufgetreten.
bei System.IO.__Error.WinIOError(Int32 errorCode, String maybeFullPath)
bei System.IO.FileStream.Init(String path, FileMode mode, FileAccess access, Int32 rights, Boolean useRights, FileShare share, Int32 bufferSize, FileOptions options, SECURITY_ATTRIBUTES secAttrs, String msgPath, Boolean bFromProxy, Boolean useLongPath)
bei System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options)
bei System.IO.StreamReader..ctor(String path, Encoding encoding, Boolean detectEncodingFromByteOrderMarks, Int32 bufferSize)
bei System.IO.StreamReader..ctor(String path)
bei MyProject.Form1.onCreated(Object sender, FileSystemEventArgs e) in F:\Dokumente und Einstellungen\MyName\Eigene Dateien\Visual Studio 2010\Projects\MyProjectFolder\MyProject\Form1.cs:Zeile 155.

Wobei Zeile 155 die Streamreader-zeile ist. Ich bin langsam am verzweifeln, weil ich das Problem nicht einmal verstehe. Mal klappts, mal nicht. Könnt ihr mir weiterhelfen?

Oh den Link habe ich glatt übersehen. Werde ich mir sofort anschauen, allerdings habe ich das von mir erstellte Bild mit dem echten Farbkanal verglichen (IrfanView) und die sehen exakt identisch aus.. bist du sicher das meine Variante falsch ist?

Ich hab jetzt folgendes gemacht:

for (int x = 0; x < bitmap.Width; x++)
                {
                    for (int y = 0; y < bitmap.Height; y++)
                    {
                        Color pxl = img.GetPixel(x, y);
                        Color redPxl = Color.FromArgb(pxl.R, pxl.R, pxl.R);
                        imgRed.SetPixel(x, y, redPxl);
                    }
                }

Sollte jetzt dies der Redkanal sein?

Ja ich möchte mir gerne nur den R-Kanal anzeigen lassen. Die Methode habe ich wie gesagt im Internet gefunden und invertiert die Farbe, ich hatte gedacht das könnte man eventuell gleich weiter verwenden.

Geschwindigkeit ist mir eigentlich nicht wichtig, allerdings möchte ich auch nicht 4 Minuten warten bis mir das Bild angezeigt wird.

Hallo,

ich habe ein Bitmap von welchem ich mir die einzelnen RGB-Kanäle jeweils anzeigen lassen möchte.

Ich bin schon so weit, dass ich ich mir über LockBits mir den Bereich sichere.

Ich hab im Internet etwas gefunden, was über Bitmanipulation geht, allerdings geht es in dem Beispiel um Farbe invertieren und nicht um das auslesen eines einzelnen Kanals. Ich hab auch schon gefunden, dass jedes 3te Bit die Informationen des Rotkanals beinhalten soll, allerdings kriege ich dazu einfach keinen Code hin.

Der bisherige Code sieht so aus:

        enum Filter : int
        {
            alpha = -0x1000000,
            red = 0xff0000,
            green = 0x00ff00,
            blue = 0x0000ff,
            gb = green | blue,
            rgb = red | green | blue
        }

       public static void InvertColors(Bitmap bitmap)
       {
           // Lock the image for editing
           System.Drawing.Imaging.BitmapData lockData = bitmap.LockBits(
               new Rectangle(0, 0, bitmap.Width, bitmap.Height),
               System.Drawing.Imaging.ImageLockMode.ReadWrite,
               System.Drawing.Imaging.PixelFormat.Format32bppArgb);

           // Create an array to store image data
           int[] imageData = new int[bitmap.Width * bitmap.Height];
           // Use the Marshal class to copy image data
           Marshal.Copy(lockData.Scan0, imageData, 0, imageData.Length);

           for (int i = 0; i < imageData.Length; i++)
           {
               imageData[i] =
                   (imageData[i] & (int)Filter.rgb)// Invert value and extract RGB
                  | imageData[i] & (int)Filter.alpha; // Combine with original alpha
                  
           }

           // Copy image data back
           Marshal.Copy(imageData, 0, lockData.Scan0, imageData.Length);
           // Unlock image
           bitmap.UnlockBits(lockData);
       }

Wenn ich z.B. den Filter Filter.gb verwende, dann zeigt er mir auch die beiden Farbkanäle von Green und Blue an, wenn ich das ganze aber nur mit Filter.red probiere, dann wandelt er das Bild quasi farbig.. obwohl es ja eigentlich grau sein sollte 😕

Ich wäre für jeden Rat dankbar.

Seufz, es tut mir leid, aber ich probier jetzt schon seit Stunden und es ergibt sich nichts brauchbares.

Also erstmal, soweit ich das jetzt mitbekommen habe, ist der Ressourcenmanager von Visual Studio also für den Arsch? Was macht der denn ueberhaupt wenn er nix von alleine einbindet?!

Ich hab bisher meine Bilder in einem Unterordner Bilder von meinem Projekt. Darauf zugreifen funktioniert ja auch wunderbar, aber so wollte ich das halt nicht haben. Mir wärs lieber gewesen wenn die Dateien in ner .resx oder so gewesen wären.

Ich wollte das ganze jetzt mit nem Dictionary machen, aber irgendwie versteh ich das noch nicht so recht...
Ich hab folgendes:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <BitmapImage x:Key="ICOON" UriSource="<welche adresse kommt hier nun rein>?"/>

</ResourceDictionary>

Muss das jetzt ne relative Adresse sein, muss das jetzt die Adresse auf meiner Festplatte sein, also z.B. C:\Eigene Bilder.... oder was?

Weiterhin kommt folgender Fehler, wenn ich das in der App einbinden will:> Fehlermeldung:

Warnung 1 Der Designer unterstützt das Laden von Wörterbüchern nicht, in denen ResourceDictionary-Elemente ohne Schlüssel mit anderen Elementen innerhalb einer einzigen Auflistung gemischt werden. Stellen Sie sicher, dass die Eigenschaft "Resources" keine ResourceDictionary-Elemente ohne Schlüssel enthält, bzw. dass das ResourceDictionary-Element das einzige Element in der Auflistung ist. F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\TESTPokerGui_preRelease(1)\TESTPokerGui_preRelease\PokerGui\app.xaml 7 9 PokerGui

Also die Sache ist die, ich will das später als Installation anbieten.. und wenn man das dann installiert, dann sollen natürlich die Bilder etc. mitgenommen werden. Wenn die allerdings als normale Source dabeiliegen, dann kann man die ja voll easy ändern usw.. und das ist nicht unbedingt gewollt!

Wird das ResourceDictionary automatisch angelegt, wenn ich etwas in den Ressourcenmanager lade? Wofür ist der sonst da, wenn der nix macht?! -.-

Ich wills ja gerade als Ressource haben und nicht als Source..:/

Hallo, ich bin gerade am verzweifeln.

Ich möchte meinem Projekt gerne Bilder als Ressourcen beilegen. Ich nutze Visual Studio 2010. Ich klicke auf meinen Projektnamen, wähle Eigenschaften und dann Ressourcen und füge mein Bild hinzu. Jetzt ändere ich die Eigenschaft der Ressource noch auf Embedded.

Wie kann ich jetzt in XAML auf dieses Bild zugreifen?

Folgende Stelle macht Probleme:

<Window
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"
	x:Class="PokerGui.Window1"
	x:Name="Window"
	Title="Texas Hold'em Poker - Western Edition"
	Width="400" Height="300" ResizeMode="CanMinimize" WindowStartupLocation="CenterScreen" Icon="{StaticResource ICOON}" Closing="Window_Closing">

Er meckert und sagt das er die Ressource nicht finden kann. Was mach ich denn falsch?

@gfoidl
Tolle Idee! Dadurch hab ich nun festgestellt, dass es überhaupt keine Änderung gab!

@talla
Du hast mich gerettet. Es war genau wie du gesagt hast, der Wert wurde in einer Funktion gesetzt. Nun funktioniert wieder alles wie es soll.

Das ist ja das Problem. Es kommt kein Fehler. Es kommt gar nichts, darf ich hier 2 Screenshots posten? Dann könnte ich eventuell besser zeigen was ich meine. Ich will weder ein Event fangen, noch Controls aktualisieren lassen...

Ich habe ein Binding auf eine Klasse. Am Anfang wird alles korrekt angezeigt und übernommen. Sobald ich jedoch auf diesen Button klicke, ist es als ob das Binding nicht mehr existiert. Der Text des Labels wurde einfach auf "" gesetzt.

Hallo, ich habe eine Klasse mit einer String-property "Name".

In meinem GUI nutze ich das Binding zum anzeigen des Namens. Das funktioniert auch alles am Anfang. Wenn ich jedoch auf einen Button klicke, welche einen Workthread startet (und meine komplette Logik abarbeitet) dann wird der Name auf einmal nicht mehr angezeigt, als ob kein Binding mehr existieren würde. Was könnte die Ursache dafür sein? Wisst ihr wie man das beheben könnte?

Ich hab zwar keine Ahnung warum, aber es klappt.. manchmal reicht es dem leihen ja so schon 😉

Warum sollte ein Window nicht auf KeyDown-Events reagieren können? Es wäre ja ziemlich sinnlos wenn mir Visual Studio diese Option unter Ereignisse anbietet, wenn die Komponente am Ende damit gar nichts anfangen kann oder?

Hallo,

heute ist wirklich der Wurm drin. Ich hab ein Window in WPF und dieses soll eigentlich ein KeyDown-Event verwalten. Nur wird dieses niemals aufgerufen. Es scheint als Blocke eine andere GUI-Komponente dieses Ereignis? Kann das sein? Wenn ja, wie könnte man rausfinden welche Komponente das blockt... und warum? Ich hab schon probiert den Focus auf das Window zu setzen und dann das KeyEvent aufzurufen.. aber so klappt das nicht.

Ich hätte jetzt doch noch eine Frage:

Ich hab jetzt das Closing Event überschrieben und die CancelEventArgs.Cancel überschreiben, damit sich das Fenster nicht mehr schließt.
Gibt es jetzt trotzdem noch eine Möglichkeit das Schließen des Fensters zu erzwingen? Die Close() Methode ruft ja lediglich die zwei Events Closing und Closed auf.. also dürfte es ja so nicht funktionieren oder?

Habs jetzt hinbekommen:
Zu beachten dabei war, das Event Window_Closing zu bearbeiten und die CancelEventArgs.Cancel Eigenschaft auf "true" zu setzen.

Danke an eure Hilfe.

Okay tut mir leid.

Ich habe das jetzt als Singleton umgesetzt... das einzige Problem ist jetzt, wenn man das Fenster schließt, hat er scheinbar auch das Objekt zerstört. Zumindestens kommt eine Exception, wenn ich es nach dem schließen erneut öffnen will:> Fehlermeldung:

System.InvalidOperationException wurde nicht behandelt.
Message=Visibility kann nicht festgelegt oder Show, ShowDialog oder WindowInteropHelper.EnsureHandle können nicht aufgerufen werden, nachdem ein Window geschlossen wurde.
Source=PresentationFramework
StackTrace:
bei System.Windows.Window.VerifyCanShow()

Hallo,

an Singleton hatte ich auch schon gedacht. Ist vielleicht wirklich die sinnvollste Lösung.
Was genau meinst du mit Application Manager? Ich hab lediglich ein Hauptfenster, wo ich halt ein anderes aufrufen kann, lediglich zur Ausgabe von ein paar zusätzlichen Informationen.

@winSharp93
Ist ShowDialog nicht modal? Dann würde ich ja nicht mehr in meinem Haupfenster arbeiten können.

Hallo ich habe in WPF ein Window namens Instructions. Dieses kann man per Button-Click oder Key-Down-Event aufrufen.

Bisher mach ich lediglich foldens:

Instructions windowInstructions = new Instructions();
windowInstructions.show();

Das Problem ist, wenn man nun erneut auf den Button klicken würde, würde sich ja noch ein Fenster öffnen und noch eines und und und...

Das möchte ich nun verhindern. Gibt es irgendeine Option für das Window wo ich sagen kann, dass er nur eine einzige Instanz zur Laufzeit gleichzeitig haben darf?

Hallo,
das wäre eine gute Idee, aber mir ist gerade noch eine eingefallen und wollte mal fragen was ihr davon haltet:

Ich hab insgesamt nur 7 Buttons. Also eine recht kleine überschaubare Anzahl an Keys die ich zu verwalten habe. Daher hab ich mir überlegt, ich lege 2 Collections (Array/List) an und füge sämtliche Keys hinzu.

Beide Collections sind am Anfang identisch, die eine dient zur Defaultbelegung, die andere zur "aktuellen".
Wenn man einen Key ändern will, geht man die gesamte Liste durch und prüft irgendwo schonmal die Taste vorkommt, wenn ja, dann ändert man diese einfach in dem man sie durch ihre default-Belegung ersetzt, wenn nicht kann man ja einfach den Key direkt ändern.

Ich find das eigentlich recht schlank, ließe sich sogar einfach erweitern.. was meint ihr?

Ich rufe das Invoke so auf:

        private void activePlayer()
        {
if (Dispatcher.CheckAccess())
            {
               //do something
            }

            else
            {
                Dispatcher.Invoke(new voidAsyncDelegate(activePlayer), null);
            }
}

Ich hasse Fehler die sich nicht reproduzieren lassen 😕

Hallo, das mache ich ja, aber gleichzeitig läuft der Workthread weiter und ich glaube das verursacht in manchen Fällen Probleme...

Hallo, ich muss mit einem Workthread arbeiten, weil die Logik "relativ" lange braucht um ihre Aktionen zu berechnen, sonst friert ja das Gui ein.

Allerdings kommt jetzt auf einmal immer folgender Fehler:> Fehlermeldung:

Eine Ausnahme (erste Chance) des Typs "System.Threading.ThreadAbortException" ist in mscorlib.dll aufgetreten.
In System.Threading.ThreadAbortException ist eine Ausnahme vom Typ "mscorlib.dll" aufgetreten, doch wurde diese im Benutzercode nicht verarbeitet.
Der Thread '<Kein Name>' (0x924) hat mit Code 0 (0x0) geendet.

Ich hab aber gar nichts an meinen Threads verändert und die haben früher auch funktioniert... (zumindestens sah es für mich so aus...)

Den Thread erzeuge ich in meiner Gui so:

private System.Threading.Thread workThread;
workThread = new System.Threading.Thread(table.gameRound);
workThread.Start();

Mein Problem ist jetzt gerade, dass ich nicht weiß wie ich den Fehler finden soll, denn er kommt nur manchmal!!! Manchmal laeuft alles wie es soll und manchmal macht er was falsch.. 😕

Weiteres Problem ist bei mir, um irgendwas im GUI anzuzeigen muss ich mit recht vielen Events arbeiten, das Problem ist aber, das der Code ja nicht auf meine Events wartet... gibts ne Möglichkeit IM Workthread zu sagen "wait()" oder im Guithread vllt? Und dann auch wieder ne Funktion "start();"? Mir nützt aber kein wait mit ner festen Zeitangabe 😕 Weil ich die Zeit ja nicht weiß wie lange der Rechner brauch um etwas auszuführen.. ach man alles so kompliziert..

Okay ich hab nochmal genauere Fragen:

Muss die Ringlist eine statische Klasse sein?

Wenn ich versuche meine RingList von IList oder List<T> abzuleiten, dann bekomme ich richtig viele Fehler:> Fehlermeldung:

Fehler 1 "PokerGui.RingList<T>" implementiert den Schnittstellenmember "System.Collections.IEnumerable.GetEnumerator()" nicht. F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\TESTPokerGui_stand_17_Juli_updateNo0\PokerGui\RingList.cs 9 11 PokerGui
Fehler 2 "PokerGui.RingList<T>" implementiert den Schnittstellenmember "System.Collections.ICollection.IsSynchronized" nicht. F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\TESTPokerGui_stand_17_Juli_updateNo0\PokerGui\RingList.cs 9 11 PokerGui
Fehler 3 "PokerGui.RingList<T>" implementiert den Schnittstellenmember "System.Collections.ICollection.SyncRoot" nicht. F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\TESTPokerGui_stand_17_Juli_updateNo0\PokerGui\RingList.cs 9 11 PokerGui
Fehler 4 "PokerGui.RingList<T>" implementiert den Schnittstellenmember "System.Collections.ICollection.CopyTo(System.Array, int)" nicht. F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\TESTPokerGui_stand_17_Juli_updateNo0\PokerGui\RingList.cs 9 11 PokerGui
Fehler 5 "PokerGui.RingList<T>" implementiert den Schnittstellenmember "System.Collections.IList.IsFixedSize" nicht. F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\TESTPokerGui_stand_17_Juli_updateNo0\PokerGui\RingList.cs 9 11 PokerGui

Das sind nur ein paar..

Naja, im Endeffekt möchte ich eigentlich einfach mit einer Liste arbeiten, aber es bietet sich bei mir an, bzw. es ist eigentlich schon fast ein "muss", dass ich eine RingListe verwende. Darum wollte ich mir die RingListe so zusammenbauen, wie eine normale Liste (damit wäre also auch eine Abfrage, wenn die Liste größer als 2 ist, gemeint)

Ich sehe gerade, ich habe oben das myRinglist.Count vergessen 😕 Das besser ich gleich nach!

Ich hab jetzt noch IEnumerable implementiert.. jetzt schauts ganz gut aus!

Hallo, ich brauche eine Ringliste. Soweit ich weiß gibt es sowas nicht in C#, deswegen müsste man sich diese selber schreiben. Bisher kam ich auch ganz gut vorran, jetzt stoße ich aber auf ein kleines Problem:

Ich möchte z.B gerne folgendes sagen:

if (myRinglist.Count > 2)
//do something

Allerdings weiß ich leider nicht, wie ich die Count zu implementieren habe damit das funktioniert. Ich habe schon versucht den Source-Code von der Collections.Generic.List zu finden, aber scheinbar kommt man da nicht so einfach ran wie in Java z.B.

MSDN hat mich bisher auf folgendes gebracht:

public static int Count<T>(this IEnumerable<T> source,Func<T, bool> predicate)

Allerdings leider ohne implementierung (siehe Enumerable.Count)

Wisst ihr genaueres?

Oha, damit haust du mich jetzt ein bisschen aus den Socken. Ich möchte lediglich Einfachbelegungen, also "Q", "A" etc belegen.

Bisher habe ich anstatt der "Action" einfach einen String genommen und diesen dann immer mit switch etc. zugeordnet (find ich ziemlich unschön).

Deinen Code konnte ich leider nicht ganz nachvollziehen... ich nehme an der kommt in eine eigene Klasse welche ich mit ICommand erweitere..

Ich wäre sehr dankbar falls du noch ein bisschen genauer erklären könntest, oder einen weiterführenden Link anzubieten haettest.

Warum nicht beides? Dann kannst du für jeden Key nachschauen was du tun musst und kannst für jede Action den zugehörigen Key finden und tauschen.

Du meinst also, ich soll zwei Dictionaries anlegen? Also quasi immer in beiden alles überschreiben?

Auch das hat leider nicht geklappt.

Ich habe das ganze jetzt nochmal mit einer String Property ausprobiert. Auch diese wird nicht angezeigt! Es liegt also nicht am Key selbst, sondern an der Klasse oder an dem DataContext oder so.. seltsam ist, ich hab das genau so auch schon bei anderen Klassen gemacht und da hat es geklappt.

Es wird nichts im Ausgabefeld angezeigt. Lediglich 1 Warnung, die aber in einer anderen Klasse ist und definitiv nichts mit dem Binding zu tun hat. (Unerreichbarer Code wurde entdeckt|gewollt).

Okay ich habe den Fehler gefunden es das ist wirklich peinlich 😕
Man sollte das Binding wohl gleich zur Initialisierung setzen... und nicht erst irgendwann später. Tut mir leid für die Unannehmlichkeiten.

Der DataContext ist Optionen, richtig. Deine Frage verunsichert mich jetzt ein wenig, das klingt so als ob das schlecht modelliert wäre?

Den DataContext habe ich so angegeben:

btn_test.DataContext = Optionen.get();

Wobei in der Optionen das so aussieht:

 private static Optionen INSTANCE = new Optionen();
public static Optionen get()
        {
            return INSTANCE;
        }

Mir wurde mal gesagt, das dies dem Singleton Pattern entspricht. Also rein theoretisch wollte ich das genau so haben, aber er zeigt halt nichts an.

Das habe ich ja probiert/gemacht..

Content="{Binding Path=MyKey, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"

Aber er zeigt nichts an.. Das ist das Problem 😕

Hallo,

ich habe eine Klasse die so aussieht:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;
using System.ComponentModel;

namespace PokerGui
{
    class Optionen : INotifyPropertyChanged
    {
        private Key myKey;

        #region INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropretyChanged(string propertyName)
        {
            var handler = this.PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        #endregion

        public Key MyKey
        {
            get { return myKey; }
            set {myKey = value; this.OnPropretyChanged("MyKey"); }
        }
    }
}

Ich möchte aber eigentlich nicht den Key selbst, sondern lediglich seinen zugehörigen Namen an einen Button binden. Also quasi an MyKey.ToString();

Geht das mit dem Binding direkt? Einzige Möglichkeit die mir bisher eingefallen ist, wäre für den Key eine zweite Property mit dem Rückgabewert "String" zu schreiben. Allerdings habe ich natürlich noch mehrere Keys und das wäre damit recht viel Source-Code.

Hm.. irgendwie sagt mir die Seite von msdn jetzt nicht so viel..
Ich hab jetzt noch nicht genau verstanden, wie ich die Datei als uri deklarieren kann, aber wenn die erstmal als uri drin ist, dann kann ich:

 Uri uri = new Uri("/Subfolder/ResourceFile.xaml"); 

benutzen, um das Bild zu adressieren?

Okay, also folgendes:

Ich habe ein Bild, das nennt sich einfach "btn_SB.png". Dieses soll in der Image-Komponente von WPF angezeigt werden.
Darum habe ich die Datei in den Ressourcenmanager geladen. (Rechtsklick auf den Projektnamen - Eigenschaften - Ressourcen - Existierende Datei hinzufügen)

Jetzt ist das Problem, wie kommt man da ran? Ich hab bisher diese Möglichkeit probiert:

ImageSource image = (ImageSource)FindResource("btn_SB");

Allerdings sagt er mir, dass die Ressource nicht gefunden wird:> Fehlermeldung:

System.Windows.ResourceReferenceKeyNotFoundException wurde nicht von Benutzercode behandelt.
Message=Die Ressource "btn_SB" wurde nicht gefunden.
Source=PresentationFramework
StackTrace:
bei MS.Internal.Helper.FindResourceHelper.DoTryCatchWhen(Object arg)
bei System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
bei MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)
bei System.Windows.Threading.Dispatcher.WrappedInvoke(Delegate callback, Object args, Int32 numArgs, Delegate catchHandler)
bei MS.Internal.Helper.FindResourceHelper.TryCatchWhen()
bei System.Windows.FrameworkElement.FindResource(Object resourceKey)
bei PokerGui.PlayingWindow.showInitGame(Card c1, Card c2) in F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\PokerGui_stand15JINIno2\PokerGui\PlayingWindow.xaml.cs:Zeile 403.
InnerException:

Find ich seltsam, vorhin hab ich die Ressource noch gefunden? Hm.. vllt habe ich was am Code geaendert, aber das Problem ist, selbst wenn ich die Ressource finde, dann ist sie vom Typ System.Drawing.Bitmap und die lässt sich leider nicht einfach in die Komponente System.Windows.Media.Image einbinden. Deswegen gibts ja relativ viele Möglichkeiten diese erst in einen Stream zu laden und daraus wieder herauszulesen.. ich hab so ne Funktion hier:

public static void ConvertImageToWpfImage(System.Windows.Controls.Image imageComponent, System.Drawing.Image image)
        {
                using (System.Drawing.Bitmap dImg = new System.Drawing.Bitmap(image))
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        dImg.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);

                        System.Windows.Media.Imaging.BitmapImage bImg = new System.Windows.Media.Imaging.BitmapImage();

                        bImg.BeginInit();
                        bImg.StreamSource = new MemoryStream(ms.ToArray());
                        bImg.EndInit();

                        imageComponent.Source = bImg;
                    }
            }
        }

Das funktioniert auch, nur danach ist die Transparenz meines Bildes einfach weg. Stattdessen wird dann einfach statt der Transparenz schwarz angezeigt.

Ich muss aus dem Projekt am Ende nen Setup machen, also quasi soll man das Projekt auf anderen Rechnern installieren können. Ich weiß halt nicht, wie ich die Bilder sonst noch mitschleppen kann, ohne ne Ressource. Ansonsten würde ich halt über relative Pfade versuchen das Bild anzusprechen 😕

Hallo, ich habe eine WPF Anwendung.
Dort habe ich eine Komponente vom Typ System.Windows.Media.Image. Nun habe ich ein transparentes Bild ("bild.png") und möchte dieses in der Komponente benutzen. Das ganze soll nicht über Xaml, sondern durch C#-Code gelöst werden.

Weiterhin soll das Projekt später auch installiert werden, das heißt, ich kann keine absoluten Pfadangaben verwenden und bin daher gezwungen?! auf Ressource-Dateien zurückzugreifen. Ich habs bisher aber nicht geschafft, dieses (mit transparenz) in meine Komponente einzufügen.

Für jeden Beitrag wäre ich dankbar.

Hallo,

ich arbeite zur Zeit an einem WPF - Projekt und bin mehr oder weniger auf Clean-Code angewiesen. Daher sollte ich wohl ein Entwurfsmuster verwenden, speziell das MVVM - Pattern.

Allerdings stellen sich mir ein paar Fragen:
Ich habe ein einziges View, dieses sollte alle Elemente beinhalten bzw. lediglich ihre Initialisierung
Dafür baue ich mir ein ViewModel welches mögliche Events (ClickEvents etc.) beinhaltet und diese per CommandBinding an die View übergibt?
Weiterhin habe ich gelesen, dass man für jedes Model eine weitere ViewModel schreibt, warum?
Dann habe ich doppelt soviele Klassen die ich aber gar nicht brauche, bzw was sollen diese ViewModels beinhalten? Als Beispiel:

Ich habe eine Klasse Person, mein Model kann auf dieser Klasse arbeiten, mein ViewModel (für die View) kennt mein Model, kann also auch auf der Klasse, speziell DataBinding arbeiten. Wozu dann ein eigenes ViewModel?

Weiterhin die Frage, was genau versteht man denn unter Commands? Ich weiß dass es vordefinierte Commands gibt, wie z.B. CUT oder SAVE... allerdings brauch man sowas ja nun nicht immer?!

Ich würde meine Anwendung jetzt folgendermaßen aufbauen:
View:

class myView {
private MyViewModel vm;

init(){
vm = new MyViewModel();
}
}

ViewModel

class MyViewModel {
private MyModel model;

public MyViewModel(){
model = new MyModel();
}

....

//Events

....
}

Model

class MyModel {
//die eigentliche arbeit...
}

Wäre das so korrekt?

Wär es nicht günstiger Key und Action zu tauschen? ALso:

Dictionary<Action, Key> 

Dann könnte ich jedesmal die Action löschen und dann mit dem neuen Key neu setzen...
Andernfalls ein Beispiel:

Wenn ich Key als Key und Action als Value nehme, und ich möchte meiner Aktion "Hüpfe" den Buchstaben H zuweisen. Wie sollte ich dann die alte Belegung von Hüpfe löschen bzw. überschreiben? Oder hab ich nen Denkfehler?

Edit: Ah, ich seh gerade, dass ich damit gar nicht wirklich der Doppelbelegung vorbeugen würde.
Ich würde die alte Action löschen und quasi die mit nem neuen Value neu hinzufügen. Ist denke ich auch machbar 😃

Hallo, ich möchte gerne mein Programm auch per Tastatur steuern lassen.
Da das ganze nutzerfreundlich gestaltet werden soll, möchte ich dem Nutzer die Möglichkeit geben, die Belegung nach seinen Wünschen zu gestalten.

Jetzt wollte ich fragen, wie man das Ganze am Besten verwalten könnte? Es soll natürlich keine Belegung doppelt vorkommen, das heißt, wenn ein Buchstabe gewählt wird, der bei einer anderen Belegung schon vorhanden ist, wird die alte Belegung gelöscht. (Hier ist die Frage, wie kann man das umsetzen?)

Zur Zeit hatte ich lediglich eine Klasse mit Attributen:

private Key Action1;
private Key Action2;
....

Allerdings lässt sich hier schlecht vergleichen ob die Buchstaben schon belegt sind.. erst recht, wenn ich später noch Änderungen oder weitere Aktionen hinzufüge.

Meine zweite Idee wäre eine Collection/Array gewesen, aber außer stupides durchgehen aller Actions fällt mir hier auch keine bessere Idee ein...

Was meint ihr?

Hm.. jetzt bomberdierst du mich aber mit Fremdwörtern 😉
Ich hatte vermutet, das wäre nach dem MVVM Prinzip, folgendes:

GUI - Fenster ruft -> Optionen Einstellungsfenster auf
Optionen Einstellungsfenster schreibt die Einstellung in eine extra Klasse
GUI - Fenster ruft Einstellungen über diese Klasse auf..

Rein theoretisch stört mich die Verbindung zwischen GUI -> Optionen, aber wie soll man sonst das öffnen. Allerdings scheint das ich wohl das MVVM nicht ganz verstanden habe?

Trotzdem funktioniert das mit ShowDialog, vielen Dank 😃

Hallo,
ich möchte folgende Funktion umsetzen:

Ich möchte sowas wie ein Optionsmenü haben, wo man einer Funktion eine Taste zuordnen kann. Meistens kennt man sowas aus Spielen, wo man die Steuerung neu belegen kann. Wenn man auf den Button oder das Textfeld klickt, dann öffnet sich ein Fenster wo dann immer steht: "Geben sie eine Taste ein" und diese Taste ist dann der neue Wert.

Ich hab jetzt überlegt wie man das umsetzen könnte und habe dann an ein modales Dialog gedacht, nur krieg ich das nicht umgesetzt. Ich habe ein neues Fenster erstellt, dort lediglich ein Label eingefügt was den Text anzeigt. Wenn man eine Taste drückt, wird diese an eine Klasse übergeben (MVVM-Prinzip) und das Fenster wieder geschlossen.

Soweit funktioniert das auch, nur weiß ich nicht wie ich das "modale" umsetze. Ich hab das Fenster lediglich mit new erzeugt und dann per Show aufgerufen, aber mein UI bleibt deswegen ja nicht einfach stehn. Könnt ihr mir helfen?

Verstehe ich das richtig, die Property fürs enum soll String zurückliefern?

Geht das denn?
Ansonsten könnte man rein theoretisch einfach ne String Variable setzen, wenn man die State Property setzt, und dann mit dem DataBinding diesen String überwachen...

Vllt meintest du ja auch sowas? 😃

Danke.

Noch eine Frage:

Ich habe ein Enum:

private State myState;

public enum State{
[Description("Test1")] ONE,
[Description("Test2")] TWO
}

Ich möchte jetzt per DataBinding dieses State ausgeben, allerdings die Description. Gibt es eine Möglichkeit dem DataBinding zu sagen, es soll die GetDescription oder so aufrufen?

So ich hab das jetzt einfach umgangen, allerdings habe ich nun einen weiteren Fehler gefunden, kennt sich jemand damit aus?

Fehlermeldung:
FatalExecutionEngineError wurde erkannt.
Message: Die Laufzeit hat einen schwerwiegenden Fehler entdeckt. Fehleradresse: "0x58e29ddd" in Thread "0x964". Fehlercode: 0x80131623. Bei diesem Fehler könnte es sich um ein Problem in der CLR oder in den unsicheren oder nicht verifizierbaren Teilen des Benutzercodes handeln. Übliche Ursachen dieses Bugs sind Marshallerfehler für COM-Interop oder PInvoke, die den Stapel beschädigen können.

Problem:
Der Fehler taucht nicht immer auf >.<

Aufjedenfall hattet ihr recht, jetzt scheint das DataBinding zu funktionieren.
Danke für eure Hilfe.

Hey erstmal Danke, das funktioniert... seltsam warum das bei mir nicht geklappt hat.
Ich habe jetzt das Problem, dass ich jetzt ne statische Methode auch aufrufen will, aber jetzt kommen solche Fehlermeldungen:

Fehler 2 Für das nicht statische Feld, die Methode oder die Eigenschaft "System.Windows.Threading.Dispatcher.CheckAccess()" ist ein Objektverweis erforderlich. F:\Dokumente und Einstellungen\Lotus\Eigene Dateien\Expression\Blend 4\Projects\PokerGui\PokerGui\CardSheet.cs 35 18 PokerGui

Gibt es nicht eine Möglichkeit zu sagen, rufe diese Funktion in einem bestimmten Thread auf?

Also so:
GUI Thread ruft Work Thread auf..
Work Thread feuert ein Event
Das Event weiß, es soll definitiv im GUI-Thread stattfinden

Im Endeffekt ist es ja genau das Invoke, aber irgendwie hatte ich gehofft dass es doch auch noch anders geht, also z.B. GuiThread.Methodenaufruf() oder so 😄

Edit:
Ich habs jetzt mit Dispatcher.CurrentDispatcher hinbekommen, dass der Fehler nicht mehr auftaucht, allerdings behauptet der Debugger trotzdem, dass es sich dabei um einen anderen Thread als den GUI-Thread handelt. Ich habe gelesen, dass CurrentDispatcher eventuell sogar einen neuen Thread anlegt..?

Hier mal das Snippet:

private delegate void convertImageDelegate(System.Windows.Controls.Image imageComponent, System.Drawing.Image image);

 public static void ConvertImageToWpfImage(System.Windows.Controls.Image imageComponent, System.Drawing.Image image)
        {
//            if (image == null)
//                throw new ArgumentNullException("image", "Image darf nicht null sein.");

            if (!Dispatcher.CurrentDispatcher.CheckAccess())
            {
                Dispatcher.CurrentDispatcher.Invoke(new convertImageDelegate(ConvertImageToWpfImage), new Object[] { imageComponent, image });
            }
            else
            {
                using (System.Drawing.Bitmap dImg = new System.Drawing.Bitmap(image))
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        dImg.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);

                        System.Windows.Media.Imaging.BitmapImage bImg = new System.Windows.Media.Imaging.BitmapImage();

                        bImg.BeginInit();
                        bImg.StreamSource = new MemoryStream(ms.ToArray());
                        bImg.EndInit();

                        imageComponent.Source = bImg;
                    }
                }
            }
        }

Hm.. ich wollte das jetzt mal mit Threads ausprobieren, aber irgendwie ist das seltsam.

Ich habe im GUI einen neuen Thread angelegt und gestartet (die lange Berechnung)
In diesem Threads werden ab und zu Events gefeuert und an das GUI weitergeleitet, jetzt ist ja das Problem, dass ich nur auf meine Elemente aus dem GUI-Thread zugreifen kann.

Darum habe ich mir einen delegate für meine Funktion gebastelt

private delegate void asyncDelegate(int x, int y);

Folgende Methode wollte ich dann aufrufen:

private void getMoney(int x, int y)
{
this.Dispatcher.Invoke(new asyncDelegate(getMoney), new Object[]{x,y});

txtbox1.Text = x.ToString();
...
}

Wenn ich das jetzt starte, kommt allerdings ein StackOverFlow, also dachte ich, ich sollte vllt vorher abfragen ob das Invoke überhaupt nötig ist, in WPF sollte man das über Dispatcher.CheckAcces machen, aber das findet mein VS gar nicht.. sieht einer den Fehler?

Das Objekt habe ich im C#-Code gebindet:

        private void bindingElements(int end)
        {
            for (int i = 0; i < end; i++)
            {
                textblockListChips[i].DataContext = table.myPlayersList[i];
                //table.myPlayersList[i].PropertyChanged += new PropertyChangedEventHandler(test_PropertyChanged);
            }
        }

Wobei in der ersten Liste sämtliche Textblöcke sind, welche ich mit der zweiten Liste der Personen verbinde. Kann es daran liegen, dass ich die Programmlogik nicht in einem extra Thread laufen habe?

Oh ja, tut mir leid, dass ist, weil ich mein Projekt lediglich hier abstrahiert dargestellt habe, es ist dasselbe als wenn ich Path=Guthaben geschrieben hätte 😉 (Property vom Guthaben)

Wenn das nicht in einem Thread laeuft, wie kann er dann quasi "parallel" zur Laufzeit meines Programms den Wert aendern?

Folgendes:
GUI zeigt mir das Guthaben an
Jetzt wird eine mathematische Berechnung durchgeführt und sobald irgendwas an dem Guthaben sich ändert soll die Änderung im GUI sichtbar sein. Es kann aber passieren dass die Logik noch weiter läuft und somit noch weitere Änderungen am Guthaben passieren.

Ich hab nochmal nachgeschaut, es wird kein Wert irgendwie an die Property gebunden.