Tentative de lecture ou d'écriture de mémoire protégée. C'est souvent une indication que l'autre mémoire est corrompue

Je ne comprends vraiment pas comment est cette erreur qui se passe au présent code. Veuillez vérifier le code vous-même

    void dispatcherTimer_Tick(object sender, EventArgs e)
{
    string srUrl = lstLocalIndex[irLocalIndex] + lstMainIndex[irMainIndex].Replace("0;","");

    Task.Factory.StartNew(() =>
    {
        startNewWindow(srUrl);
    });

}


    void startNewWindow(string srUrl)
{
    NewWindowThread<TitleWindow, string>(c => new TitleWindow(c), srUrl);
}

Maintenant ce code est où l'erreur se produise. Je vais également joindre la capture d'écran

        private void NewWindowThread<T, P>(Func<P, T> constructor, P param) where T : Window
    {
        Thread thread = new Thread(() =>
        {
            T w = constructor(param);
            w.Show();
            w.Closed += (sender, e) => w.Dispatcher.InvokeShutdown();
            try
            {
                System.Windows.Threading.Dispatcher.Run();
            }
            catch
            {

            }
        });
        thread.SetApartmentState(ApartmentState.STA);
        try
        {
            thread.Start();
        }
        catch
        {

        }
    }

Cette erreur provoque ensemble du logiciel jet d'erreur et arrêter de travailler, même si je les appelle à nouveau thread 🙁

Cette ligne jetant erreur Système.De Windows.Le filetage.Répartiteur.Run();

Veuillez vérifier également la capture d'écran

Tentative de lecture ou d'écriture de mémoire protégée. C'est souvent une indication que l'autre mémoire est corrompue

C# WPF 4.0

Vous êtes réellement à l'aide de deux threads, l'un dans le Task et puis le Thread, mieux, il suffit de placer le code que vous voulez exécuter en tant que code de démarrage dans le Thread.
J'ai aussi essayé encore de l'application de s'écraser. Et ce qui se passe après un certain temps, pas instantanément. Il fonctionne comme 30 minutes, puis crash. Le bruit des changements de temps.
Non, ils disent que votre mémoire est cassé. Il doit en être ainsi! (btw, c'est la chose la plus stupide message d'erreur que j'ai rencontrés après "erreur non spécifiée").

OriginalL'auteur MonsterMMORPG | 2012-04-02

access-violation c#memory-corruption unhandled-exception wpf

0

Vous utilisez un lambda comme une fonction de thread. Cette lambda est appelée sur un nouveau thread. À l'
moment le fil est en fait créé, il va chercher l'argument de l'offre, qui est une variable locale srUrl, mais par le temps ce qui se passe à votre fonction (dispatcherTimer_Tick) a déjà sorti, donc srUrl sera dans une partie de la pile n'est pas correctement définie (d'où la violation d'accès). La solution facile est de définir une variable dans la classe et des trucs de la srLoc de là rapidement. Un plus la bonne solution est de passer à la srLoc comme argument:
```
() =>
{
    startNewWindow(srUrl);
}
```
devient
```
(Action<string>){x => {startNewWindow(x);},
            new object[] {srUrl}
```
Maintenant la fonction de référence et une bonne copie de la chaîne sont enregistrées pour l'appel de fonction, et il n'est pas question que l'original srUrl est hors de portée, par les temps le fil de coups de pied dans. Je ne suis pas sûr de savoir si la tâche de l'usine permet le tableau d'arguments pour être transmis. les répartiteurs ont généralement une surcharge pour cela, alors peut-être vous voulez laisser votre fenêtre de prendre soin de cela.

Maintenant vous pouvez faire cela à quelques reprises, de sorte que vous mai besoin d'envelopper les arguments à chaque fois qu'ils sont passés.

Merci pour la réponse. En fait j'ai résolu mon problème par le biais de l'écriture d'une autre application qui lit les url à partir d'un fichier. Donc, je suis en train de créer des exe maintenant, au lieu de nouvelles fenêtres. Quelques fois ces nouvelles exe donnant des erreurs, mais le logiciel de continuer à fonctionner 🙂 Mais votre réponse est vraiment professionnelle, je l'aime.
Cette réponse peut sembler logique, mais c'est faux. La fermeture de la capture de la variable locale (qui est appelée une variable indépendante). Voir aussi ici: codethinked.com/c-closures-explained
Si cela était vrai, alors votre code de casser avant même l'affichage de la fenêtre. Après l'affichage de la fenêtre de la srUrl n'est pas utilisé.
merci pour le lien. Je l'utiliser lors de la redirection d'un appel à partir d'un autre thread le thread d'INTERFACE utilisateur (avec l'expéditeur.BeginInvoke). Si la fermeture de travail, de l'emballage ne serait pas nécessaire, mais si je n'en ai pas, j'obtiens exactement la violation d'accès mémoire mentionnés ici. Alors peut-être que la variable est censé être capturé, mais il ne l'est pas.

OriginalL'auteur Nzc
2

J'ai été aux prises avec ce problème avec un client, et voici ce que j'ai trouvé.

Nous travaillons sur une application WPF qui fait beaucoup de filetage et d'arrière-plan travailleur à traitement de. Cette exception a soudainement commencé à se propager et j'ai commencé à faire quelques recherches. J'ai enfin trouvé le coupable, après environ une heure de l'enquête:
```
        var worker = new BackgroundWorker();
        worker.DoWork += (o, ea) => Dispatcher.BeginInvoke(new Action(() =>
        {
            //do some heavy processing here, plus UI work, then call another method.

            //inside that other method, I found this:
            var thread = new Thread(() =>
            {
                //do some heavy processing.
            }) { IsBackground = true };
            thread.Start();
        }));
```
Ce qui semble avoir été qui arrive, c'est que le fond travailleur est la finition de son travail et de retour de son exécution. Cependant, le thread est créé à l'intérieur de ce contexte travailleur n'est pas fait de traitement et retourne seul à trouver que le thread qu'il a été créé sur a déjà disparu de la portée, de sorte que l'AccessViolationException.

Pour déboguer ce, je suggère de prêter attention à l'endroit où l'exception se produit, et examinant attentivement votre pile d'appel, qui peut ou peut ne pas avoir été détruit ou perdu selon que vous êtes ou non à l'intérieur d'un fil lorsque l'exception est lancée.

OriginalL'auteur Joe Brunscheon
1

J'ai eu le même problème il y a quelques temps.

L'erreur se produit parce que votre fenêtre est hors de portée et le Garbage Collector détruit.

À l'aide de ShowDialog() devrait résoudre le problème. Notez que le fait de ne pas bloquer les autres threads parce que la fenêtre est modale dans le thread appelant.
```
private void NewWindowThread<T, P>(Func<P, T> constructor, P param) where T : Window
{
    Thread thread = new Thread(() =>
    {
        System.Windows.Threading.Dispatcher.Run();
        T w = constructor(param);
        w.ShowDialog();
        w.Dispatcher.InvokeShutdown();
    });
    thread.SetApartmentState(ApartmentState.STA);
    try
    {
        thread.Start();
    }
    catch
    {
        //log&handle exceptions
    }
}
```
Si c'est vrai... vous pourriez faire quelque chose simmilar par la fixation d'un événement dans l'événement chargé et l'attente que l'événement avant de quitter le délégué.
Cela a un sens, mais ne serait-il pas bloquer l'INTERFACE utilisateur nouvellement créé fenêtre?
merci pour la réponse. vais essayer de faire maintenant.

OriginalL'auteur surfen

Vous devez vous connecter pour publier un commentaire.