Hallo!

Ich wusste nicht genau ob es hier oder in den Bereich Grafik gehört.
Es soll ein (Winforms-)Programm entstehen welches 2 WPF-Controls hostet (dies ist kein Problem). In dem einen Control wird ein Bild (korrektes Seitenverhältnis, zentriert) angezeigt. Dieses Control kann vom Benutzer in der Größe geändert werden. Auch dies habe ich bereits geschafft.
Auf diesem Bild (nur auf dem Bild) soll man ein Rechteck (feste Größe) verschieben können. Das grundsätzliche Verschieben eines Rectangle schaffe ich auch. Nur die Begrenzung auf das Bild schaffe ich nicht.
Alles was unterhalb des Rechtecks sichtbar ist, soll auf einem 2ten Control (auf einem anderen Monitor) in groß (skaliert) angezeigt werden. Auch dieses schaffe ich nicht.

Zur besseren Anschauung habe ich ein Bild zusammengebastelt (siehe Anhang).

Habt Ihr mit soetwas Erfahrung oder Beispiele gefunden?
Ich kann zwar gut suchen, aber nicht wenn ich nicht weiß wonach ich suchen muss 🙂
Beispiele oder Links zu Tutorials oder auch Stichwörter sind gerne genommen.

Mein Quellcode zum anzeigen des Bildes (erstes Control):
Ich bin mir nicht sicher was besser ist, ein Rectangle mit ImageBrush in einem Grid oder ein Image auf einem Canvas.

Das UserControl liegt in einem Dockpanel.

<Grid Background="AliceBlue">

        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*" />
        </Grid.ColumnDefinitions>

        <Canvas x:Name="canvas"
                Grid.Row="0"
                Grid.Column="0"
                Background="Beige">
            <Image Height="{Binding ElementName=canvas, Path=ActualHeight}"
                   Width="{Binding ElementName=canvas, Path=ActualWidth}"
                   Source="{Binding ImageSource}"
                   HorizontalAlignment="Center"
                   VerticalAlignment="Center"
                   Stretch="Uniform" />
            <!--<Rectangle Height="{Binding ElementName=canvas, Path=ActualHeight}"
                       Width="{Binding ElementName=canvas, Path=ActualWidth}">
                <Rectangle.Fill>
                    <ImageBrush ImageSource="{Binding ImageSource}"
                                Stretch="Uniform"
                                AlignmentX="Center"
                                AlignmentY="Center"
                                presentation:Freeze="True" />
                </Rectangle.Fill>
            </Rectangle>-->
        </Canvas>

    </Grid>

Vielen Dank im Voraus!

Hallo!
Folgendes Problem:
Ich hatte ein MSDN-Abo (war auch bereits 2 mal verlängert), welches zum 01.06.2015 abgelaufen ist. mit hilfe des Abos konnte ich iso-Dateien für verschiedene OS-Versionen herunterladen. Zum Testen verwende ich VMs und brauche nun die Keys für diese verschiedenen OS-Versionen. Angefordert hatte ich die Keys bereits vorher, aber nie benutzt.
Wenn ich jetzt die alten (bezahlten) bereits angeforderten Keys exportieren möchte, dann sagt er mir mein Abo wäre abgelaufen und das geht nicht.

Ist dies wirklich so oder gibt es dafür eine Funktion, die man erst freischalten lassen muss?

Hallo!
Folgendes Szenario.*im Büro wird SVN genutzt (kein SVN-Server sondern nur ein "File-Repository", max. 3 Nutzer) *Ich bin häufiger in einer Aussenstelle und muss auch dort einchecken, reverten etc. können *Dafür würde ich gerne mit GIT arbeiten und dann später alles ins SVN zurück-commiten *Ab und zu das (lokale) GIT-Repository mit dem aktuellen Stand des SVN aktualisieren *SVN ist also so etwas wie das "Haupt-Repository" *So wenig Kommandozeile wie möglich (bin Mausschubser, nutze bisher TortoiseSVN) *Es wird nur Windows 7 oder > genutzt

Ich habe bisher keine richtige Anleitung dafür gefunden. Wenn dann nur unter Linux oder nur über Kommandozeile. Einzelne (wenig sagende) Beispile gab es auch.
Eine "richtige" Anleitung mit den einzelnen Abläufen habe ich bis jetzt nicht gfeunden.

Könnt ihr mir da helfen bzw. Hinweise auf Anleitungen geben?

Hallo!
Ich habe unter anderem 2 Tabellen in einer DB die sich gegenseitig referentieren. Es gibt immer nur eine 1:1-Beziehung, daher keine koppel-Tabelle wie bei m:n-Beziehungen.
Tabelle A hat einen zusammengestzen PK (eigene Id + Id aus Tabelle B). Es gibt Beziehungen zwischen den Tabellen (logisch, es gibt ja PK und FK).
sollte egal sein, aber es ist eine Access-2007-DB.

Nun habe ich aber Probleme bei einem Update der DB (arbeite mit einem DataSet und Adaptern).
Wie muss ich mein Design anpassen odre am Besten natürlich nur meinen Code beim Update, damit folgendes ohne Problemem funktioniert?

Eintrag in Tabelle A (A1) hat Verweis auf einen Eintrag in Tabelle B (B1) welcher wieder einen Verweis auf einen anderen eintrag in Tabelle A (A2) hat. Dieser hat wiedre einen Verweis auf einen anderen Eintrag in Tabelle B (B2) ohne Verweis auf Tabelle A.
kurz: A1 -> B1 -> A2 -> B2

Wie muss ich jetzt bei einem Insert/Update vorgehen, wenn noch keiner der Einträge vorhanden ist?

Im Anhang ein Bild um den Text eventuell besser zu verstehen.

Hallo!

Wie kann ich in einem WPF-Projekt welches nach MVVM umgesetzt ist die Selektion einer ListBox bei einem Druck auf ESC (oder einem Klick in den freien Bereich) entfernen?

Meine View hat keinen Code im CodeBehind.
Hier ein wenig meines Quellcodes:

View:

<UserControl .....
d:DataContext="{d:DesignInstance Type=viewModel:ColorChooserViewModel, IsDesignTimeCreatable=True}">
...
 <ListBox  ...
                  ItemsSource="{Binding AvailableColors}"
                  SelectedItem="{Binding ChosenColor}"
                  SelectionMode="Single">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    ...
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
...
</UserControl>

ViewModel:

public class ColorChooserViewModel : ModelBase
    {
...
public ChooseColor ChosenColor
        {
            get { return chosenColor; }
            set
            {
                if (chosenColor != value)
                {
                    chosenColor = value;
                    RaisePropertyChanged(() => ChosenColor);

                    DelegateCommand.RaiseCanExecuteChanged();
                }
            }
        }

        public ObservableCollection<ChooseColor> AvailableColors
        {
            get { return availableColors; }
            set
            {
                if (availableColors != value)
                {
                    availableColors = value;
                    RaisePropertyChanged(() => AvailableColors);
                }
            }
        }
...
}

Model:

public class ChooseColor : ModelBase
    {
...
 public int Id
        {
            get { return id; }
            set
            {
                id = value;
                RaisePropertyChanged(idArgs);
            }
        }

        public BitmapImage Image
        {
            get { return image; }
            set
            {
                image = value;
                RaisePropertyChanged(imageArgs);
            }
        }
...
}

Hallo!
Ich habe ein WinForm-UserControl mit mehreren ComboBoxen. Diese werden beim ersten Anzeigen des Controls geladen (mit Werten befüllt und auf einen bestimmten Wert gesetzt).
Nun hatte ich die Idee dieses Befüllen parallel ablaufen zu lassen (mittels Task). Das Laden der Daten ist nicht das Problem sondern das Befüllen der Boxen mit den Daten dauert lange.
Da ich dazu aber einen Zugriff auf das UI benötige, brauche ich ja auch einen TaskScheduler.
Wenn ich jetzt aber 7 Tasks mit UiScheduler habe, müssen dann nicht die Tasks auf einander warten und ich habe keinen Geschwindigkeitsvorteil mehr?

Habe ich das so richtig verstanden oder habet ihr andere Tipps?

Ich habe ein Anwendung, die unter .Net 4 full (x86) erstellt wurde.
Es werden aber auch diverse unmanaged Technologien benutzt (DirectShow, DirectDraw, DirectSound etc.). Eine Umstellung auf MediaFoundation ist wegen Win XP nicht machbar.

Nun habe ich allerdings das Problem, dass mein Programm nach ca. 1 Std. Benutzung die Krätsche macht, weil eine OutOfMemory-Exception auftritt.

Eine Beobachtung mit gängigen Memory-Profilern (JustTrace, dorTrace und ANTS standen zur Verfügung) hat keine Schwachstellen im Managed-Bereich gefunden.
Die Verwendeten Caches geben ihren Speicher auch wunderbar wieder frei.

Die Vermutung ist also, dass das Problem der unmanaged Bereich ist.

Wie kann ich die Vermutung bestätigen und viel wichtiger: Wie finde ich die Fehler/Lecks?

Hallo!
Dann werde ich wiedre eine ganz normale Abhängigkeit ins Dateisystem hinzufügen und NuGet nicht nutzen.
Schade das soetwas nicht möglich ist bzw. nur mit extra Aufwand.

Ich erstelle mir jetzt selber eine signierte Variante nach diesem Muster:

\===========================
Strong-Name für Third-Party
\===========================
Disassemble
"C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\ildasm.exe" /all /out=ThirdParty.il ThirdParty.dll

Rebuild (*.resources werden automatisch integriert)
"C:\Windows\Microsoft.NET\Framework\v4.0.30319\ilasm.exe" ThirdParty.il /dll /resource=ThirdParty.res /key=YourKey.snk 

Verify
"C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\sn.exe" -vf ThirdParty.dll

Hallo!
Bisher hatte ich eine alte Version einer 3rd-Party-Dll (NAudio) genutzt. Dies war eine Refernez auf ein lokales Verzeichnis, wo alle Abhängigkeiten per Hand angepasst/aktualisiert wurden.
Nun wollte ich die Vorteile von NuGet nutzen und habe das entsprechende Package hinzugefügt.
Leider kann ich jetzt meine Anwendung nicht mehr kompilieren, weil die Datei aus NuGet keinen StrongName hat.
Dies führt meiner Meinung nach dazu, dass NuGet völlig wertlos ist (in meinem Fall).

Gibt es da eine einfache Lösung für (nicht nur für dieses Packet)?

Hallo!
Vielen Dank für die Vorschläge!
Ich habe mich jetzt für eine Lösung entschieden und die funktioniert auch ausreichend für meinen Fall. Geht vielleicht eleganter, aber "It just works." war erst mal wichtiger.

Bevor ich die Daten an die View weitergebe, prüfe ich wie lange die letzte Weitergabe her ist.

private const int UPDATE_INTERVAL = 150;
private DateTime lastUpdateCurrentStatus = DateTime.MinValue;

//Das Event das aufgerufen wird
public void SetProgressCurrentStatus(ProgressStatusEventArgs args)
        {
            if (canUpdateCurrentStatus())
            {
                view.SetProgressCurrentStatus(args);
            }
        }

//Aktualisierung nur alle 150ms zulassen
private bool canUpdateCurrentStatus()
        {
            var result = false;

            var now = DateTime.UtcNow;
            var diff = now - lastUpdateCurrentStatus;
            if (diff.Milliseconds > UPDATE_INTERVAL)
            {
                lastUpdateCurrentStatus = now;
                result = true;
            }

            return result;
        }

Hallo!
Ich habe ein Fenster welches mir den Fortschritt von bestimmten Operationen anzeigen kann. Dazu bekommt es einfach die anzuzeigenden Daten von den jeweiligen Controllern für diese Operation überliefert.
Nun können die Controller aber "sehr geschwätzig" sein und mehrmals pro Sekunde neue Daten senden (per Event). Dann kommt die Oberfläche nicht mehr mit bzw. flackert sehr oft (Labels werden aktualisiert).
Da es sich ja um ein Problem der Oberfläche und nicht der Controller handelt, würde ich das Problem ganz gerne an der Oberfläche (bzw. in dem Controller der Oberfläche) beheben.

Wie kann ich es verhindern das es mehrmals pro Sekunde neue Daten gibt?
Mein erster Gedanke war ein Timer, aber das kommt mir zu kompliziert vor. Gibt es da irgendwelche Musterlösungen oder Best Practices?

Vielen Dank im Voraus!

Erstmal Danke für die Rückmeldungen.

Die Felder A,B etc. sind ja nur Platzhalter fürs Forum. Da stehen sonst Datum, Nummern etc. drin.
herbivore hat natürlich recht. Es ist NICHT eindeutig wann eine Nachricht zu Ende ist.
Aber für meinen Fall kann ich das ignorieren, weil das selten bis gar nicht vorkommt.
Mit Regex kann man das machen, ja. Ich mache das aber erst mal mit string.Split etc. und hinterher schaue ich ob das mit RegEx performanter (Speicher,Tempo etc.) läuft.

Hallo!
Ich muss eine Datei parsen die EIGENTLICH ein festes Muster hat. Aber es kann auch vorkommen, dass eine Information über mehrere Zeilen geht.

Bsp:

A|B|C|Nachricht mit variabler Länge
A|B|C|Nachricht mit variabler Länge
A|B|C|Nachricht mit variabler Länge
A|B|C|Nachricht mit variabler Länge
diese Zeile gehört noch zur vorherigen Nachricht

sogar Leerzeilen können möglich sein
A|B|C|Nachricht mit variabler Länge
A|B|C|Nachricht mit variabler Länge

Das ich mit ReadLine und Split arbeiten muss, habe ich schon verstanden.
Nur wie behandele ich die Sonderfälle?
Meine Idee ist:

• immer die vorherige Zeile speichern
• wenn die nächste Zeile NICHT mit A anfängt, dann füge den Inhalte der Zeile an die vorherige Nachricht an

Gibt es dafür eine bessere/performantere Altenative unter .Net3.5?

Hallo!
Vielen Dank für die Vorschläge.

Ich habe jetzt so etwas wie eine "Frankenstein-Lösung".
Meine Lösung ist ein Zusammenwurf von OpenGeoDB, OpenStreetmap und statistisches Bundesamt.
Ich habe aus allen Listen die PLZ geparst und dann doppelte Einträge entfernt. Da ich im Programm einen Hinweis auf alle Quellen habe, gibt es auch kein Problem mit den Lizenzen.

Eine Online-Lösung ist nicht notwendig/möglich. Jetzt habe ich eine Liste mit PLZ direkt als Resource im Programm integriert.

Damit Ihr auch was davon habt: siehe Anhang

Vielen Dank nochmal!

Hallo?
Habt ihr eine Quelle für eine aktuelle Liste mit PLZ (DE)?
Man müsste meinen, dass einem der Bund so etwas bereitstellt, aber ich habe nichts gefunden. Vielleicht findet ihr ja eine öffentlich zugängliche kostenlose Quelle, welche von unseren Steuergeldern finanziert wurde 😃

verwendetes Datenbanksystem: Access 2010

Ich habe eine Frage zur Verwendung von OleDbDataReader und yield return.
Da die Verwendung von yield return ja ein paar Vorteile hat (unter bestimmten Umständen bessere Performance) wollte ich fragen ob man den unten stehenden Code so umschreiben kann, dass yield return verwendet wird. Und wenn ja wie. Die nächste logische Frage wäre: Macht das überhaupt Sinn?

public IEnumerable<string> GetItems()
        {
            lock (lockObject)
            {
                var result = new List<string>();

                try
                {
                    OpenConnection();

                    using (OleDbDataReader reader = commandSelectItems.ExecuteReader())
                    {
                        if (reader != null && reader.HasRows)
                        {
                            findOrdinalColumnNumbers(reader);

                            while (reader.Read())
                            {
                                string foundItem = reader.GetString(indexItem);
                                if (Überprüfung(foundItem))
                                {
                                    result.Add(foundItem);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException("Fehler beim Lesen der Datenbank.", ex);
                }
                finally
                {
                    CloseConnection();
                }

                return result;
            }
        }

Bei so vielen Textboxen und Labels schreit das ja förmlich nach einem Grid zur Dateneingabe.
Kann man vielleicht das Layout dahingehend ändern?

Hallo!

Ich bin auf der Suche nach einem Control (welches es hoffentlich so schon gibt).
Zur Veranschaulichung ist ein Bild angehängt.

Aufgaben des Controls:*mehrspaltige Ansicht ermöglichen (1-3 Spalten reicht) *"Kapitel" anzeigen können, sind quasi ein Art Überschrift für einen Abschnitt (im Bild die grünen Felder) *Bild-Elemente anzeigen (orangene Felder), es sollen Bilder angezeigt werden *Drag&Drop der angezeigten Elemente *Kontextmenü abhängig vom gewählten Element

Gibt es so etwas eventuell schon?

Vielen Dank für eventuelle Hinweise!

Autsch!
Ich hatte voll den Knoten in meine Gehirn Denkprozesse. Keine Ahnung warum, aber ich dachte das Dispose der Basisklasse muss ja auch noch aufgerufen werden...

Die Lösung ist so simpel (abgeleitete Klasse geändert):

public class BenutzerManager : BaseManager<Bo>
 {
/// <summary>
         /// Overloaded Implementation of Dispose.
         /// </summary>
         /// <param name="isDisposing"></param>
         /// <remarks>
         /// <para><list type="bulleted">Dispose(bool isDisposing) executes in two distinct scenarios.
         /// <item>If <paramref name="isDisposing"/> equals true, the method has been called directly
         /// or indirectly by a user's code. Managed and unmanaged resources
         /// can be disposed.</item>
         /// <item>If <paramref name="isDisposing"/> equals false, the method has been called by the 
         /// runtime from inside the finalizer and you should not reference 
         /// other objects. Only unmanaged resources can be disposed.</item></list></para>
         /// </remarks>
         protected override void Dispose(bool isDisposing)
         {
             // If you need thread safety, use a lock around these 
             // operations, as well as in your methods that use the resource.
             lock (lockObject)
             {
                 try
                 {
                     if (!IsDisposed)
                     {
                         if (isDisposing)
                         {
                             // Release all managed resources here 

                             //etc.

                             GC.SuppressFinalize(this);
                         }

                         // Release all unmanaged resources here

                         // REMEMBER explicitly set root references to null to expressly tell the GarbageCollector
                         // that the resources have been disposed of and its ok to release the memory allocated for them.
                     }
                 }
                 finally
                 {
                      base.Dispose(isDisposing);
                 }
             }
         }
 }

Nützlich ist auch dieser Link gewesen:
Detaillierte Untersuchung von IDisposable - Ableiten von einem verwerfbaren Typ

Edit:
gfoidl war schneller mit dem Link

Hallo!

Ich habe ein Problem mit dem Implementieren von IDisposable.
ich habe mehrere ManagerKlassen welche sich um verschiedene BOs kümmern. Dabei gibt es eine Basis-ManagerKlasse von der alle anderen Manager erben.
im Moment bekomme ich eine Stackoverflow-Exception in der Dispose-Methode der einzelnen Manager.

Wie kann ich das richtig implementieren?

Hier mein (Pseudo-)Code.

public class BaseManager<T> : IDisposable where T : class, IComparable<T>
    {
	
	#region IDisposable Members
        
        protected bool IsDisposed { get; set; }

        /// <summary>
        /// Implementation of Dispose according to .NET Framework Design Guidelines.
        /// </summary>
        /// <remarks>Do not make this method virtual.
        /// A derived class should not be able to override this method.
        /// </remarks>
        public void Dispose()
        {
            this.Dispose(true);

            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Overloaded Implementation of Dispose.
        /// </summary>
        /// <param name="isDisposing"></param>
        /// <remarks>
        /// <para><list type="bulleted">Dispose(bool isDisposing) executes in two distinct scenarios.
        /// <item>If <paramref name="isDisposing"/> equals true, the method has been called directly
        /// or indirectly by a user's code. Managed and unmanaged resources
        /// can be disposed.</item>
        /// <item>If <paramref name="isDisposing"/> equals false, the method has been called by the 
        /// runtime from inside the finalizer and you should not reference 
        /// other objects. Only unmanaged resources can be disposed.</item></list></para>
        /// </remarks>
        protected virtual void Dispose(bool isDisposing)
        {
            // If you need thread safety, use a lock around these 
            // operations, as well as in your methods that use the resource.
            lock (lockObject)
            {
                try
                {
                    if (!IsDisposed)
                    {
                        if (isDisposing)
                        {
                            // Release all managed resources here 
                            if (connectionToDatabase != null)
                            {
                                CloseConnection();
                                //etc.
                            }
                        }

                        // Release all unmanaged resources here

                        // REMEMBER explicitly set root references to null to expressly tell the GarbageCollector
                        // that the resources have been disposed of and its ok to release the memory allocated for them.
                    }
                }
                finally
                {
                    IsDisposed = true;
                }
            }
        }      

        #endregion
}

public class BenutzerManager : BaseManager<Bo>
{
 /// <summary>
        /// Overloaded Implementation of Dispose.
        /// </summary>
        /// <param name="isDisposing"></param>
        /// <remarks>
        /// <para><list type="bulleted">Dispose(bool isDisposing) executes in two distinct scenarios.
        /// <item>If <paramref name="isDisposing"/> equals true, the method has been called directly
        /// or indirectly by a user's code. Managed and unmanaged resources
        /// can be disposed.</item>
        /// <item>If <paramref name="isDisposing"/> equals false, the method has been called by the 
        /// runtime from inside the finalizer and you should not reference 
        /// other objects. Only unmanaged resources can be disposed.</item></list></para>
        /// </remarks>
        protected override void Dispose(bool isDisposing)
        {
            // If you need thread safety, use a lock around these 
            // operations, as well as in your methods that use the resource.
            lock (lockObject)
            {
			//HIER GIBT ES DIE STACKOVERFLOW-EXCEPTION
                Dispose();

                try
                {
                    if (!IsDisposed)
                    {
                        if (isDisposing)
                        {
                            // Release all managed resources here 
                            
							//etc.

                            GC.SuppressFinalize(this);
                        }

                        // Release all unmanaged resources here

                        // REMEMBER explicitly set root references to null to expressly tell the GarbageCollector
                        // that the resources have been disposed of and its ok to release the memory allocated for them.
                    }
                }
                finally
                {
                    IsDisposed = true;
                }
            }
        }
}

Ich habe schon soetwas gedacht.
Dann ignoriere ich die Warnung an dieser Stelle einfach und alles ist gut.

Vielen Dank!

Hallo!

Ich bin dabei alten Quellcode aufzuräumen. Dazu nutze ich das "Code Analysis"-Feature von VS2010.
Dabei wurde gemeckert, dass man doch bitteschön Parameter verwenden soll. Wenn ich das so wie in der zugehörigen Hilfe umsetze bekomme ich folgende Fehlermeldung:

Fehlermeldung:
System.Data.OleDb.OleDbException: Syntaxfehler in Abfrage. Die Abfrage ist unvollständig.

Heir mein alter und neuer (Pseudo-)Code (der alte funktionierte):

private readonly string tblNameChangeLog = DAL.TableName.ToString();
private const string COL_REIHENFOLGE = "reihenfolge";

//alter Code
string selectStatement = String.Format("SELECT * FROM {0} ORDER BY {1} ASC", tblNameChangeLog, COL_REIHENFOLGE);

OleDbCommand command = connection.CreateCommand();
command.CommandText = selectStatement;

//neuer Code
OleDbCommand command = connection.CreateCommand();
command.Parameters.Add("@tableName", OleDbType.VarWChar).Value = tblNameChangeLog;
command.Parameters.Add("@order", OleDbType.VarWChar).Value = COL_REIHENFOLGE;
command.CommandText = "SELECT * FROM @tableName ORDER BY @order ASC";

Warum funktioniert der neue Code nicht und ich bekomme obigen Fehler?

EDIT:
Die Warnung von Code Analysis ist folgende:
CA2100

Aufgrund der Rahmenbedingungen habe ich die Lösung von Sarc probiert.
Diese funktioniert bei mir ausgezeichnet.

Ich musste nur eine Kleinigkeit anpassen.

ev.WaitOne(10, true);

Vielen Dank nochmal!

Hallo!

Ich habe da mal eine Frage zu einer Best-Practice.

Ich habe 2 BOs (A und B) und A hat ein Property mit einer Auflistung von mehreren Bs).
Im konstruktor von A wird ein Thread gestartet (aus dem ThreadPool) welcher das Property befüllt/initialisiert. In diesem Thread werden die einzelnen Bs geladen un der Auflistung hinzugefügt. Somit sind sie beim Zugrif auf die Auflistung bereits vorhanden (die Daten werden also bereits im Hintergrund geladen für bessere Performance).

Nun zu meinem Problem.
Wenn ich auf die Auflistung zugreife, obwohl der thread sie noch nicht gefüllt hat bekomme ich eine leere Auflistung zurück. Das ist ja ein unerwünschter Effekt des Ladens im Hintergrund.
Mein Ansatz wäre folgender:
In A gibt es eine Variable "bereits geladen" welche default auf "nein" steht. Der Thread zum Laden setzt diese Variable am Ende auf "ja".
Beim Zugriff auf die auflistung wird geprüft ob "bereits geladen" auf "ja" steht. Falls nicht dann warte ich mittels Thread.Sleep(100) bis es auf "ja" steht.

Ist das so gängige Best-Practice oder gibt es bessere Varianten? Mich stört konkret das Thread.Sleep, aber mir fällt eben keine bessere Möglichkeit ein.

Hallo!

Bei Windows XP mit SP3 ist ja kein .Net Framework 3.5 SP1 dabei.
Kann ich allerdings davon ausgehen, dass bei Windows XP mit SP3 und regelmäßigen Updates das .Net Framework 3.5 SP1 vorhanden ist?

Habe über Google und hier nichts passendes gefunden (außer das es eben nicht im SP3 enthalten ist).

Guckst du hier: www.connectionstrings.com

Hallo!
Ich habe mir ein kleines Backup-Tool geschrieben, welches von der Windows 7 Aufgabenplanung ausgeführt wird.
Wie kann ich der Aufgabenplanung mitteilen, dass mein Tool nicht erfolgreich war und es nochmal ausgeführt werden soll?

Vielen Dank im Voraus!

Hallo!
Ich habe da eine eher generelle Frage.
Konkret geht es um eine Logging-Komponente. Ich habe eine gemeinsam genutzte Bibliothek (*.Common.dll). Diese wird in ca. 20 Anwendungen verwendet. Nun wollte ich eine Logging-Funktionalität einbauen. Ich möchte NLog nutzen.
Nun würde ich aber gerne unabhängig von einem konkreten Anbieter bleiben.
Wie kann ich das erreichen?
Muss ich mir umständlich einen eigenen Wrapper schreiben oder gibt es da vielleicht schon was fertiges?
So ein Logger hat ja doch schon einiges an Funtionalität und das alles nochmal zu wrappen ist ganz schön aufwendig.
Wie macht ihr sowas? Seid ihr abhängig von einem Anbieter und nutzt dann immer in jedem Projekt eine referenz auf dessen .dll?

Was genau ist denn langsam? (Stichwort Profiler)

Zu dem Code-Abschnitt fällt mir folgendes ein:
Die Connection ist wahrscheinlich immer die Selbe, also kann man die einmal erzeugen und dann nur noch öffnen und schließen.
Ein Dataadapter und datatable scheinen überflüssig zu sein (du nutzt die ja eigentlich kaum). Probiere mal den DataReader (der ist manchmal schneller).
Das Command kann man auch nur einmal erstellen und dann mit Parameter füllen. Beim Erstellen kann man auch gleich noch *.Prepare() aufrufen.
Auf DB-Seite könnte man Indizes setzen.

Hallo!

Ich habe eine Anwendung mit der ich die MS Office Formate anzeigen kann (die entsprechenden Viewer werden mit installiert und dann Process.Start aufgerufen).
Nun würde ich gerne auch die Opendocument-Formate unterstützen (! nur anzeigen !). Leider finde ich immer nur die aodl oder andere komponenten welche nicht mehr weiter entwickelt werden.

Welches ist der aktuell beste Weg die genannten Formate anzuzeigen?
Wo gibt es eine LEICHT verständliche Anleitung dazu?
Habt ihr selber damit Erfahrung? Immerhin ist Opendocument ja ein Standard-Format.

Vielen Dank!

verwendetes Datenbanksystem: Access 2010

Hallo!
Ich habe folgendes Datenmodel:
TabA (PK,...,TabBPK)
TabB (PK,...,TabAPK)

Nun existiert jeweils eine 1:n-Beziehung auf den Feldern. Beim Update/Insert kommt logischerweise ein Fehler, dass der Datensatz in der anderen Tabelle vorhanden sein muss.

Kann man bei Access die Beziehungen/Indizes während eines Update/Insert dekativieren und danach wieder aktivieren (der SQL-Server kann das ja)? Wenn ich bei meinem Typed-Dataset EnforceConstarints setze hat das ja keine Auswirkung auf die DB.

Oder ist mein Datenmodell falsch? Wie kann/muss ich das umbauen?

Durch Probieren habe ich jetzt folgende Lösung erarbeitet.
Wenn es Hinweise oder Vorschläge gibt, dann bitte gerne melden.

// das Ganze läuft in einer Schleife über alle Datensätze der TabA, daher ist curRow die aktuelle Zeile in TabA
var result = from TabA in ds.TabA
                  where TabA.PK == curRow.PK
                  join TabC in ds.TabC
                  on curRow.PK equals TabC.PK_A into resultantQuery
                  from TabC in resultantQuery
                  join TabB in ds.TabB
                  on TabC.PK_B equals TabB.PK
                  select new
                  {
                      TabelleA = TabA,
                      TabelleB = TabB,
                      TabelleC = TabC
                  };

Ich habe ein typisiertes DataSet mit ca. 12 Tabellen und deren Relationen.
Nun möchte ich mittels Linq die Daten daraus lesen. Bei einzelnen Tabellen kann ich das auch und es klappt auch. mein Problem sind Daten die mehr als einer Tabelle liegen.

Ich habe z.B. 3 Tabellen:
TabA(PK,Feld1, Feld2,...)
TabB(PK,Feld1, Feld2,...)
TabC(PK_A,PK_B,Feld1)

Wie kann ich diese Tabellen in meiner Linq-Abfrage verknüpfen?
Ich habe scho etwas von Join gelesen, aber leider bin ich wohl zu unschlau dafür. Kann man mir jemand helfen?

Hallo!

Ich entwickle ein Programm unter .Net 3.5 SP1 und VS 2008 (portiert von .Net 1.1 und VS 2003).
Nun habe ich eine Abhängigkeit zu einer Dritthersteller-Komponente. Bei dieser zeigt mir VS in den Eigenschaften bei Laufzeitversion die Version "1.1.4322" an. Alle anderen Abhängigkeiten (eigene und fremde) haben bei Laufzeitversion "2.0.50727" stehen.

Anscheinend funktioniert das Programm.
Kann es irgendwelche Nebenwirkungen haben? Wenn ja welche? Reicht es aus das .Net Framework 3.5 SP 1 zu installieren? Wie kann ich eventuelle Nebenwirkungen beseitigen?

Leider habe ich keinen zugriff auf das SQL-Statement.
Gibt es keine andere Lösung dafür?

Hallo!

Ich möchte ein typisiertes DataSet erstellen (über VS 2008). Dieses enthält eine Spalte mit dem Typ Boolean.
In der DB (Access) ist diese Spalte als string (also Text in Access) angelegt. Allerdings enthält diese Spalte entweder 1 oder 0.
Wenn ich das DatSet füllen will bekomme ich die Meldung, dass 0/1 nicht in Boolean gewandelt werden kann. Vermutlich soweit korrekt, ABER:

Wie kann ich dennoch den Typ der Spalte im DataSet auf Boolean lassen?

Kann man das beim Füllen irgendwie umwandeln?

Hallo!

Ich möchte einen Wert in die Registry schreiben.
Eckdaten:

• Programm ist .Net 1.1
• System wo Wert geschrieben wird ist Win 7 64bit

Unter einem Windows 7 32bit funktioniert das Ganze, auch unter Windows XP 32bit.
Unter Win 7 64 bit funktioniert es NICHT. auch nicht wenn ich das Programm als Administrator aufrufe (über Kontextmenü).

Könnt ihr mir sagen woran das liegt und wie ich das dennoch machen kann?

Bevor nach Code gefragt wird, hier ist er:

private static void adjustOldPowerPoint()
        {
            RegistryKey rootKey97 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\PowerPoint.Show.8");
            if (rootKey97 != null)
            {
                object currentValue = rootKey97.GetValue("BrowserFlags");
                if (currentValue != null)
                {
                    string newValue = currentValue.ToString();
                    if (!newValue.Trim().Equals("0"))
                    {
                        setRegistryValue(rootKey97, "BrowserFlags", 0);
                    }
                }
                else
                {
                    setRegistryValue(rootKey97, "BrowserFlags", 0);
                }
            }
        }

        public static void setRegistryValue(RegistryKey rootKey, string nameToSet, object valueToSet)
        {
            if (rootKey != null && nameToSet != null && nameToSet.Length > 0 && valueToSet != null)
            {
                try
                {
                    rootKey.SetValue(nameToSet, valueToSet);
                }
                catch (UnauthorizedAccessException ex)
                {
                    throw new UnauthorizedAccessException(Environment.NewLine + "In den Registrierungswert kann nicht geschrieben werden." +
                        Environment.NewLine +
                        "RootKey: " + rootKey.Name +
                        " Name: " + nameToSet +
                        " Value: " + valueToSet.ToString() +
                        Environment.NewLine, ex);
                }
            }
            else
            {
                throw new ArgumentNullException();
            }
        }

Der Ordner soll tranparent sein --> Schaue dir mal Eigene Bilder, Eigene Musik etc. genauer an.
Ist also kein Fehler sondren gewollt.

Hallo!

Wie bekomme ich heraus ob meine Form gerade angezeigt wird?

Hintergrund:
Ich habe eine Dualescreen-Anwendung und auf dem 2ten Bildschirm wird eine Form angezeigt. Von dieser soll ein Screenshot auf aiener anderen form auf dem 1ten Bildschirm angezeigt werden , ABER nur wenn die 2te Form sichtbar ist.
Soll heißen: Wenn ein anderes Fenster auf dme 2ten Bildschirm maximiert dargestellt wird bzw. angezeigt wird (meine form ist wird angezeigt aber nicht sichtbar für den nutzer) soll kein Screenshot angezeigt werden.
Im Moment ist dies jedoch der Fall.

Vielen Dank im Voraus!

Im Idealfall soll es so sein.

Hallo!

Für folgendes Problem bräuchte ich mal 1 oder 2 Ansätze.
Ich möchte in einem Grid bilder anzeigen. Allerdings kann ich das nur im OwnerDrawCell-Event machen. Also einem Event das gefeuert wird, sobald die Zelle gezeichnet werden soll.
Allerdings existieren die bilder zu diesem Zeitpunkt noch nicht im Speicher und müssen hier erst geladen werden (Image.FromFile). Zumindest trifft dies bei erste Zeichnen der Zelle zu. Nach dem ersten Zeichnen ist das Bild im Speicher.
Nun "hängt" das erste zeichnen allerdings, wenn das Bild geladen wird.

Wie kann ich die Zelle dennoch zeichnen und im Hintergrund das Bild laden. Wenn das Bild geladen ist, wird es an die Zelle übergeben. So ploppen die Bilder nach und nach auf.
wie gesagt kann ich allerdings nur in diesem Event das Bild setzen. Deshalb stehe ich etwas auf dem Schlauch.

Ich nutze zwar das C1 Flexgrid und .Net 1.1, aber es sollte ja ein generelles Verhalten/Vorgehen sein.

Vielen Dank im Voraus!

Passt perfekt hierzu:
Blogeintrag "C# – tabControl – tabPage – Fehlende Visible Eigenschaft"

Ich habe jetzt etwas weiter gebastelt und bin auch FAST fertig.

Das einzige Problem, welches mich noch stört:
In dem Moment wo man die Checkbox anklickt, wird irgendwie noch "eine kleinere Checkbox" gezeichnet. Dadurch entsteht ein unschönes flackern.
Laut meiner Recherche soll man dann den FlatStyle ändern. Das Flackern ist dann auch weg, aber:

• beim Start der Anwendung werden mehrere Checkboxen nicht korrekt gezeichnet (man sieht den Hintergrund der Anwendung "durchscheinen")
• Im Designer ist die Prozessorlast sehr hoch
• Schiebt man andere Fenster über die Anwendung werden die Checkboxen auch nicht korrekt gezeichnet

Ich habe meine "Komponente" mal als Anhang hinzugefügt.
Vielleicht würde mir jemand helfen bei der Beseitigung der restlichen Probleme, dann gibt es eine Komponente mehr fürs Forum.

Als erstes Danke für deine Antwort.

Den Text zeichne ich ja nicht selber. Wie kann ich den denn selber zeichnen? Meine Suche hier und im Internet nach "C# custom Checkbox" und ähnliches war nicht erfolgreich.

Auch nach entfernen des Events habe ich im Designer eine sehr hohe CPU-Auslastung.

Kennt jemand ein Beispiel für eine selbst gezeichnete Checkbox? Oder vielleicht eine OpenSource-Variante, damit ich mich dort einlesen kann?

Hallo!

ich arbeite das erste mal mit GDI+, aber ich habe einen guten Grund dafür.
Ich möchte eine Checkbox gestalten. Dies klappt im groben auch.
Allerdings gibt es da ein paar kleinere Gemeinheiten, wofür ich keine Lösung weiß.

• Wie auf dem Bild zu sehen ist, "liegt der Text unterhalb" der Checkbox.
• Beim "Zusammenschieben" der Form, wird auch das Viereck verkleinert, aber nicht der Text.
• Im Designer kann ich diese Komponente auch auf eine Form hinzufügen, allerdings liegt dann der Rechner brach und devenv.exe verurscaht 100% Prozessorlast.

Habt ihr ein paar Ideen für Lösungen?

Hier noch mein Quellcode:

public partial class Form1 : Form
    {
        private MyCheckbox checkedCB;
        private MyCheckbox uncheckedCB;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            checkedCB = new MyCheckbox();
            checkedCB.AutoSize = true;
            checkedCB.Location = new System.Drawing.Point(50, 200);
            checkedCB.Name = "checkedCB";
            checkedCB.TabIndex = 0;
            checkedCB.Text = "Sehr laaaaaanger Text";
            checkedCB.UseVisualStyleBackColor = true;
            checkedCB.Size = new Size(32, 32);
            checkedCB.Font = new Font("Arial", 14, System.Drawing.FontStyle.Bold);
            checkedCB.ForeColor = Color.Red;
            checkedCB.Checked = false;

            uncheckedCB = new MyCheckbox();
            uncheckedCB.AutoSize = true;
            uncheckedCB.Location = new System.Drawing.Point(50, 100);
            uncheckedCB.Name = "uncheckedCB";
            uncheckedCB.TabIndex = 1;
            uncheckedCB.Text = "A";
            uncheckedCB.UseVisualStyleBackColor = true;
            uncheckedCB.Size = new Size(32, 32);
            uncheckedCB.Font = new Font("Arial", 14, System.Drawing.FontStyle.Bold);
            uncheckedCB.ForeColor = Color.Red;
            uncheckedCB.Checked = true;

            this.Controls.Add(uncheckedCB);
            this.Controls.Add(checkedCB);
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            this.Invalidate(true);
        }
    }

    class MyCheckbox : CheckBox
    {
        private static Brush whiteBrush = new SolidBrush(Color.White);
        private static Brush blackBrush = new SolidBrush(Color.Black);
        private static Pen textPen = new Pen(whiteBrush, 3);
        private static Pen rectPen = new Pen(blackBrush, 1);
        private int buffer = 5;

        public MyCheckbox()
            : base()
        {
            textPen.EndCap = LineCap.Round;
            SetStyle(ControlStyles.DoubleBuffer, true);
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            this.SuspendLayout();

            base.OnPaint(e);
            base.FlatStyle = FlatStyle.Flat; //zwecks Flackern beim "drücken"            

            Graphics g = e.Graphics;
            RectangleF rect = new RectangleF(g.ClipBounds.X, g.ClipBounds.Y, g.ClipBounds.Height, g.ClipBounds.Height);

            if (this.Checked)
            {
                //schwarzer Hintergrund
                g.FillRectangle(blackBrush, rect);

                g.SmoothingMode = SmoothingMode.AntiAlias;
                //links-mitte/unten-mitte
                g.DrawLine(textPen, rect.Left + buffer, rect.Height / 2, rect.Width / 2, rect.Bottom - buffer);
                //unten-mitte/oben-rechts
                g.DrawLine(textPen, rect.Width / 2, rect.Bottom - buffer, rect.Right, rect.Top);
                g.SmoothingMode = SmoothingMode.None;
            }
            else
            {
                //weißer Hintergrund
                g.FillRectangle(whiteBrush, rect);
                //schwarzer Rahmen
                g.DrawRectangle(rectPen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
            }

            this.ResumeLayout();
        }
    }

Hallo!

Ich habe ein Programm welches Daten aus einem Ordner anzeigt und dort auch welche hinschreibt. Der Pfad zu dem Ordner steht in der Registry und wird stumpf genutzt (mit Hilfe von Path.Exists etc.).

C:\Pfad\Ordner

Nun sollen diese Daten auch auf einem Rechner im Netzwerk liegen. also den Ordner mit Lese-/Schreibrechten freigeben und in der Registry folgendes ändern:

\\Rechnername\Pfad\Ordner

Was muss ich dort allerdings eintragen, wenn der Rechner in einer anderen Domäne ist und ich nur mit "Domäne\Benutzername" und dem Passwort darauf zugreifen kann?

Habe es jetzt gelöst.
FlowDirection ist LeftToRight, this ist das UserControl

private void flowPanel_SizeChanged(object sender, EventArgs e)        
        {
            int maxBottom = 0;
            foreach (Control curControl in flowPanel.Controls)
            {
                if (curControl.Bottom > maxBottom)
                {
                    maxBottom = curControl.Bottom;
                }
            }

            maxBottom += abstandObenLinks;//Das ist noch ein weiterer kleiner Puffer

            this.Height = maxBottom;
        }

Danke für die Denkanstöße!
Microsoft könnte dem FlowLayoutPanel aber auch einfach ein Property verpassen wo die benötigte Größe drinnen steht ...

Edit:
Ich habe ein Control (A) mit einem FlowlayoutPanel (fill).
In das FlowlayoutPanel werden zig Controls geladen, angezeigt und automatisch angeordnet. Perfekt.
Nun soll sich das Control (A) an die Größe des FlowLayoutPanels anpassen. Die Größe des FlowLayoutPanels ändert sich aber nicht. Die Controls werden zwar in eine neue Reihe gepackt, aber die Größe des FlowLayoutPanels ändert sich nicht.

Wie kann ich die größe des Controls (A) so anpassen, dass alle Controls im FlowLayoutPanel sichtbar sind (auch wenn die Controls in einer neuen Reihen angezeigt werden)?

Beim Sizechanged oder ResizeEvent des FlowLayoutPanels ist immer die selbe Größe angegeben und ich finde auch kein Property wo die größe des benötigten sichtbaren Bereichs drinnen steht.

Ich habe das für mich entdeckt: ExceptionMessageBox des SQL Servers

Zusätzlich natürlich ein log-File erstellen, was der Nutzer dann per Mail etc. schicken kann.

Hallo!
Ich habe hier im Forum über die Begriffe Video und Video anzeigen etc. nichts brauchbares gefunden.

Ich möchte in einer Multimonitor-Umgebung Videos anzeigen (z.B. auf dem rechten Monitor ein Video in Vollbild und auf dem linken in einer kleineren Vorschau das selbe Video, quasi synchron).
Nun habe ich gelesen, dass es verschiedene Lösungen dafür gibt. Allerdings auch verschiedene Probleme damit.

Wie kann ich unter den gegebenen Voraussetzungen Videos (wmv, mpg) anzeigen?
bzw.
Wo gibt es ein Tutorial dafür?

folgende Techniken habe ich gefunden (in Klammern die jeweiligen "Probleme" die ich gefunden habe):*DirectX/DirectShow (wird nicht weiter entwickelt bzw. soll abgeschafft werden) *XNA (funktioniert das auch unter Windows XP?) *Windows Media Player Komponente (Kann die das selbe Video mehrfach anzeigen?)

Voraussetzungen:*zukunftssichere Technologie oder wenigstens leicht austauschbare Technologie *mindestens .Net Framework 3.5 SP1 *muss leider auch (noch) unter Windows XP laufen *auf 2 oder mehr Bildschirmen gleichzeitig anzeigen