WPF listbox rempli dynamiquement - comment l'obtenir pour actualiser?

Je suis nouveau sur WPF, alors j'ai pensé que c'était simple. J'ai un formulaire avec une zone de liste et un bouton. Dans le gestionnaire d'événements click pour le bouton, je fais quelque chose de manière itérative qui génère des chaînes, qui je veux mettre dans la zone de liste que je les reçois. Le code xaml de la zone de liste, c'est comme

    <ListBox Height="87" Margin="12,0,12,10" Name="lbxProgress" VerticalAlignment="Bottom">
        <ListBox.BindingGroup>
            <BindingGroup Name="{x:Null}" NotifyOnValidationError="False" />
        </ListBox.BindingGroup>
    </ListBox>

et le gestionnaire de clic est comme

private void btn_Click(object sender, RoutedEventArgs e)  
{  
  List<String> lstrFiles= new List<String>(System.IO.Directory.GetFiles   ("C:\\temp", "*.tmp");  

  foreach(string strFile in lstrFiles)  
    lbxProgress.Items.Add(strFile);  
}

Assez simple. Depuis mon opération est longue, je veux la zone de liste pour mettre à jour comme je le fais chaque un - comment puis-je obtenir la boîte pour mettre à jour dynamiquement sur chaque ajout?

Pour résumer autres réponses: toujours utiliser la liaison de données (et préférez les collections observables); ne jamais ajouter des éléments à conteneurs manuellement dans le code.
Pour résumer le commentaire ci-dessus: hein? A-t-il eu des changements dans ce domaine? Quel est le point de ôtant une telle opération simple que de mettre à jour et actualiser?

OriginalL'auteur GTAE86 | 2009-12-10

  1. 5

    Créer un ObservableCollection<string> et de définir votre zone de liste.ItemsSource à la collection. Parce que la collection est observable, la zone de liste sera mise à jour comme modification de son contenu.

    Toutefois, si votre opération est de bloquer le thread de l'INTERFACE utilisateur, cela peut empêcher WPF de la mise à jour de l'INTERFACE utilisateur jusqu'à ce que l'opération est terminée (à cause de la liaison de données WPF l'infrastructure n'obtiendrez pas une chance de s'exécuter). De sorte que vous pouvez avoir besoin pour exécuter votre opération longue sur un thread d'arrière-plan. Dans ce cas, vous ne serez pas en mesure de mettre à jour l'ObservableCollection de la thread d'arrière-plan en raison de WPF croix-threading restrictions (vous pouvez mettre à jour les propriétés, mais pas de collections). Pour contourner ce problème, utilisez Répartiteur.BeginInvoke() pour mettre à jour la collection sur le thread de l'INTERFACE utilisateur, tout en continuant de votre opération sur le thread d'arrière-plan.

    Mon opération était la copie d'un fichier, qui peut impliquer la création d'un répertoire, donc je bloque le thread d'INTERFACE utilisateur. J'ai profité de l'expéditeur.BeginInvoke fonctionnalité.

    OriginalL'auteur itowlson

  2. 4

    ne pas utiliser une Liste<>, utilisez un ObservableCollection<>. Contrairement à une Liste normale, collection Observable déclenche des événements à chaque fois qu'un élément est ajouté ou supprimé, ce sera la cause de tous les objets qui sont à l'écoute d'agir de manière appropriée--comme votre listbox rafraîchissant pour refléter les nouvelles/les éléments supprimés.

    Si vous avez besoin de tri, de regroupement, de filtrage, puis envisager d'utiliser un CollectionView.

    Tu me dis il n'y a pas de zone de liste fonction de mise à jour? Je ne peux pas utiliser une ObservableCollection si je veux contrôler lorsque les mises à jour sont faites.

    OriginalL'auteur Muad'Dib

  3. 2

    Pour une réponse complète, ici est celle du fragment de code, moins un certain code de gestion d'erreur:

    namespace Whatever  
{  
public partial class MyWindow : Window  
{  
public delegate void CopyDelegate();  
private string m_strSourceDir;  //Source directory - set elsewhere.  
private List<string> m_lstrFiles;  //To hold the find result.  
private string m_strTargetDir;  //Destination directory - set elsewhere.  
private int m_iFileIndex;  //To keep track of where we are in the list.  
private ObservableCollection<string> m_osstrProgress;  //To attach to the listbox.  
private void CopyFiles()  
{  
if(m_iFileIndex == m_lstrFiles.Count)  
{  
System.Windows.MessageBox.Show("Copy Complete");  
return;  
}  
string strSource= m_lstrFiles[m_iFileIndex];  //Full path.  
string strTarget= m_strTargetDir + strSource.Substring(strSource.LastIndexOf('\\'));  
string strProgress= "Copied \"" + strSource + "\" to \"" + strTarget + '\"';  
try  
{  
System.IO.File.Copy(strFile, strTarget, true);  
}  
catch(System.Exception exSys)  
{  
strProgress = "Error copying \"" + strSource + "\" to \"" + strTarget + "\" - " + exSys.Message;  
}  
m_osstrProgress.Add(strProgress);  
++m_iFileIndex;  
lbxProgress.Dispatcher.BeginInvoke(DispatcherPriority.SystemIdle, new CopyDelegate(CopyFiles));  
}  
private void btnCopy_Click(object sender, RoutedEventArgs e)  
{  
m_lstrFiles= new List<String>(System.IO.Directory.GetFiles(m_strSourceDir, "*.exe"));  
if (0 == m_lstrFiles.Count)  
{  
System.Windows.MessageBox.Show("No .exe files found in " + m_strSourceDir);  
return;  
}  
if(!System.IO.Directory.Exists(m_strTargetDir))  
{  
try  
{  
System.IO.Directory.CreateDirectory(m_strTargetDir);  
}  
catch(System.Exception exSys)  
{  
System.Windows.MessageBox.Show("Unable to create " + m_strTargetDir + ": " + exSys.Message);  
return;  
}  
}  
m_iFileIndex= 0;  
m_osstrProgress= new ObservableCollection<string>();  
lbxProgress.ItemsSource= m_osstrProgress;  
lbxProgress.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new CopyDelegate(CopyFiles));  
}  
}  
}

    OriginalL'auteur GTAE86