StackOverflowExceptionを防止または処理するにはどうすればよいですか？
https://stackoverflow.com/questions/206820
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
Xsl Editor 内の XslCompiledTransform.Transform メソッドの呼び出しから取得している StackOverflowException を防止または処理したい>私は書いています。問題は、ユーザーが無限に再帰的な Xslスクリプトを記述でき、 Transform メソッドの呼び出しで爆発することです。 （つまり、問題は典型的なプログラム上のエラーだけではありません。これは通常、このような例外の原因です。）
許可される再帰の数を検出および/または制限する方法はありますか？または、このコードが私に吹き飛ばされないようにする他のアイデアはありますか？
解決
Microsoftから：
.NET Frameworkから開始 バージョン2.0、StackOverflowException オブジェクトはtry-catchでキャッチできません ブロックし、対応するプロセスは デフォルトで終了しました。その結果、 ユーザーはコードを書くことをお勧めします スタックを検出して防止する オーバーフロー。たとえば、 アプリケーションは再帰に依存し、使用 カウンタまたは状態条件 再帰ループを終了します。
例外は、コードではなく、内部.NETメソッド内で発生していると想定しています。
いくつかのことができます。
- xslで無限再帰をチェックし、変換を適用する前にユーザーに通知するコードを記述します（Ugh）。
- XslTransformコードを別のプロセスにロードします（ハックですが、作業は少なくなります）。
Processクラスを使用して、変換を別のプロセスに適用するアセンブリをロードし、メインアプリを強制終了せずに、障害が発生した場合にユーザーに警告することができます。
編集：テストしたばかりです。方法は次のとおりです。
MainProcess：
// This is just an example, obviously you'll want to pass args to this.
Process p1 = new Process();
p1.StartInfo.FileName = "ApplyTransform.exe";
p1.StartInfo.UseShellExecute = false;
p1.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
p1.Start();
p1.WaitForExit();
if (p1.ExitCode == 1)
Console.WriteLine("StackOverflow was thrown");
ApplyTransformプロセス：
class Program
{
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
throw new StackOverflowException();
}
// We trap this, we can't save the process,
// but we can prevent the "ILLEGAL OPERATION" window
static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
if (e.IsTerminating)
{
Environment.Exit(1);
}
}
}
他のヒント
注 @WilliamJockuschによる賞金の質問と元の質問は異なります。
この回答は、サードパーティライブラリの一般的な場合のStackOverflowと、それらを使用してできること/できないことに関するものです。 XslTransformの特殊なケースについては、受け入れられている回答をご覧ください。
スタックのオーバーフローは、スタック上のデータが特定の制限（バイト単位）を超えるために発生します。この検出の仕組みの詳細については、こちらをご覧ください。
StackOverflowExceptionsを追跡する一般的な方法があるかどうか疑問に思っています。言い換えれば、コードのどこかに無限再帰があると仮定しますが、どこにあるのかわかりません。私はそれが起こるのを見るまで、あちこちでコードをステップ実行するよりも簡単な何らかの方法でそれを追跡したい。どれほどハッキングされているかは気にしません。
リンクで述べたように、静的コード分析からスタックオーバーフローを検出するには、決定不能である停止の問題を解決する必要があります。 特効薬がないことを確認したので、問題を追跡するのに役立つと思われるいくつかのトリックを紹介できます。
この質問はさまざまな方法で解釈できると思いますが、私は少し退屈しているので:-)、さまざまなバリエーションに分解します。
テスト環境でのスタックオーバーフローの検出
基本的にここでの問題は、（制限された）テスト環境があり、（拡張された）実稼働環境でスタックオーバーフローを検出することです。
SO自体を検出する代わりに、スタックの深さを設定できるという事実を利用してこれを解決します。デバッガは、必要なすべての情報を提供します。ほとんどの言語では、スタックサイズまたは最大再帰深度を指定できます。
基本的に、スタックの深さを可能な限り小さくすることでSOを強制します。オーバーフローしない場合は、実稼働環境用にいつでも大きくすることができます（この場合は、より安全です）。スタックオーバーフローが発生した瞬間に、それが「有効な」ものであるかどうかを手動で決定できます。
これを行うには、スタックサイズ（この場合は小さな値）をThreadパラメーターに渡し、何が起こるかを確認します。 .NETのデフォルトのスタックサイズは1 MBです。これより小さな値を使用します。
class StackOverflowDetector
{
static int Recur()
{
int variable = 1;
return variable + Recur();
}
static void Start()
{
int depth = 1 + Recur();
}
static void Main(string[] args)
{
Thread t = new Thread(Start, 1);
t.Start();
t.Join();
Console.WriteLine();
Console.ReadLine();
}
}
注：このコードも以下で使用します。
一度オーバーフローすると、意味のあるSOが得られるまで、より大きな値に設定できます。
SOの前に例外を作成する
StackOverflowException はキャッチできません。これは、発生したときにできることはあまりないことを意味します。そのため、コードに何らかの問題があると思われる場合は、場合によっては独自の例外を作成できます。これに必要なのは、現在のスタックの深さだけです。カウンターは不要です。.NETの実際の値を使用できます。
class StackOverflowDetector
{
static void CheckStackDepth()
{
if (new StackTrace().FrameCount > 10) // some arbitrary limit
{
throw new StackOverflowException("Bad thread.");
}
}
static int Recur()
{
CheckStackDepth();
int variable = 1;
return variable + Recur();
}
static void Main(string[] args)
{
try
{
int depth = 1 + Recur();
}
catch (ThreadAbortException e)
{
Console.WriteLine("We've been a {0}", e.ExceptionState);
}
Console.WriteLine();
Console.ReadLine();
}
}
このアプローチは、コールバックメカニズムを使用するサードパーティコンポーネントを扱う場合にも機能することに注意してください。唯一必要なことは、スタックトレースで一部の呼び出しをインターセプトできることです。
別のスレッドでの検出
これを明示的に提案したので、ここにこれを示します。
SOを別のスレッドで検出することもできますが、おそらくそれは役に立たないでしょう。スタックオーバーフローは、コンテキストスイッチを取得する前であっても、高速に発生する可能性があります。これは、このメカニズムがまったく信頼できないことを意味します... 実際に使用することはお勧めしません。構築するのは楽しかったので、ここにコードがあります：-）
class StackOverflowDetector
{
static int Recur()
{
Thread.Sleep(1); // simulate that we're actually doing something :-)
int variable = 1;
return variable + Recur();
}
static void Start()
{
try
{
int depth = 1 + Recur();
}
catch (ThreadAbortException e)
{
Console.WriteLine("We've been a {0}", e.ExceptionState);
}
}
static void Main(string[] args)
{
// Prepare the execution thread
Thread t = new Thread(Start);
t.Priority = ThreadPriority.Lowest;
// Create the watch thread
Thread watcher = new Thread(Watcher);
watcher.Priority = ThreadPriority.Highest;
watcher.Start(t);
// Start the execution thread
t.Start();
t.Join();
watcher.Abort();
Console.WriteLine();
Console.ReadLine();
}
private static void Watcher(object o)
{
Thread towatch = (Thread)o;
while (true)
{
if (towatch.ThreadState == System.Threading.ThreadState.Running)
{
towatch.Suspend();
var frames = new System.Diagnostics.StackTrace(towatch, false);
if (frames.FrameCount > 20)
{
towatch.Resume();
towatch.Abort("Bad bad thread!");
}
else
{
towatch.Resume();
}
}
}
}
}
これをデバッガで実行し、何が起こるのか楽しみましょう。
スタックオーバーフローの特性の使用
質問の別の解釈：＆quot; Where are
XmlWriterオブジェクトのラッパーを作成することをお勧めします。そのため、WriteStartElement / WriteEndElementの呼び出しの数をカウントします。タグの数をある数（fe 100）に制限すると、別の例外をスローできます。例-InvalidOperation。
これは、ほとんどの場合に問題を解決するはずです
public class LimitedDepthXmlWriter : XmlWriter
{
private readonly XmlWriter _innerWriter;
private readonly int _maxDepth;
private int _depth;
public LimitedDepthXmlWriter(XmlWriter innerWriter): this(innerWriter, 100)
{
}
public LimitedDepthXmlWriter(XmlWriter innerWriter, int maxDepth)
{
_maxDepth = maxDepth;
_innerWriter = innerWriter;
}
public override void Close()
{
_innerWriter.Close();
}
public override void Flush()
{
_innerWriter.Flush();
}
public override string LookupPrefix(string ns)
{
return _innerWriter.LookupPrefix(ns);
}
public override void WriteBase64(byte[] buffer, int index, int count)
{
_innerWriter.WriteBase64(buffer, index, count);
}
public override void WriteCData(string text)
{
_innerWriter.WriteCData(text);
}
public override void WriteCharEntity(char ch)
{
_innerWriter.WriteCharEntity(ch);
}
public override void WriteChars(char[] buffer, int index, int count)
{
_innerWriter.WriteChars(buffer, index, count);
}
public override void WriteComment(string text)
{
_innerWriter.WriteComment(text);
}
public override void WriteDocType(string name, string pubid, string sysid, string subset)
{
_innerWriter.WriteDocType(name, pubid, sysid, subset);
}
public override void WriteEndAttribute()
{
_innerWriter.WriteEndAttribute();
}
public override void WriteEndDocument()
{
_innerWriter.WriteEndDocument();
}
public override void WriteEndElement()
{
_depth--;
_innerWriter.WriteEndElement();
}
public override void WriteEntityRef(string name)
{
_innerWriter.WriteEntityRef(name);
}
public override void WriteFullEndElement()
{
_innerWriter.WriteFullEndElement();
}
public override void WriteProcessingInstruction(string name, string text)
{
_innerWriter.WriteProcessingInstruction(name, text);
}
public override void WriteRaw(string data)
{
_innerWriter.WriteRaw(data);
}
public override void WriteRaw(char[] buffer, int index, int count)
{
_innerWriter.WriteRaw(buffer, index, count);
}
public override void WriteStartAttribute(string prefix, string localName, string ns)
{
_innerWriter.WriteStartAttribute(prefix, localName, ns);
}
public override void WriteStartDocument(bool standalone)
{
_innerWriter.WriteStartDocument(standalone);
}
public override void WriteStartDocument()
{
_innerWriter.WriteStartDocument();
}
public override void WriteStartElement(string prefix, string localName, string ns)
{
if (_depth++ > _maxDepth) ThrowException();
_innerWriter.WriteStartElement(prefix, localName, ns);
}
public override WriteState WriteState
{
get { return _innerWriter.WriteState; }
}
public override void WriteString(string text)
{
_innerWriter.WriteString(text);
}
public override void WriteSurrogateCharEntity(char lowChar, char highChar)
{
_innerWriter.WriteSurrogateCharEntity(lowChar, highChar);
}
public override void WriteWhitespace(string ws)
{
_innerWriter.WriteWhitespace(ws);
}
private void ThrowException()
{
throw new InvalidOperationException(string.Format("Result xml has more than {0} nested tags. It is possible that xslt transformation contains an endless recursive call.", _maxDepth));
}
}
この回答は@WilliamJockusch向けです。
追跡する一般的な方法があるかどうか疑問に思っています StackOverflowExceptions。言い換えれば、私は無限を持っていると仮定します 私のコードのどこかに再帰がありますが、どこにあるのか分かりません。したい コードをステップスルーするよりも簡単な方法で追跡する 私はそれが起こるのを見るまで、あちこちで。いかにハックするか気にしない そうです。たとえば、できるモジュールがあるといいですね スタックをポーリングした、おそらく別のスレッドからでもアクティブにする 「高すぎます」と思ったレベルに達した場合は、文句を言います。にとって たとえば、「高すぎる」と設定する場合があります。 600フレームまで、 スタックが深すぎた、それは問題でなければなりません。そのようなものです 可能。もう1つの例は、1000回ごとのメソッド呼び出しを記録することです デバッグ出力への私のコード内。これはいくつかを得る可能性 過剰の証拠はかなり良いだろうし、そうではないだろう 出力をひどく爆破します。重要なのは、関与できないことです オーバーフローが発生している場所にチェックを書き込む。なぜなら 問題は、それがどこにあるかわからないことです。できれば解決策 私の開発環境がどのように見えるかに依存すべきではありません。すなわち、 特定のツールセットを介してC＃を使用していると想定しないでください（例： VS）。
このStackOverflowをキャッチするためのデバッグテクニックを聞きたいと思っているようですので、試してみてください。
1。メモリダンプ。
長所：メモリダンプは、スタックオーバーフローの原因を解決する確実な方法です。 C＃MVP＆amp;私は一緒にSOのトラブルシューティングを行い、彼はそれについてブログに行きましたこちら。
この方法は、問題を追跡する最速の方法です。
この方法では、ログに表示される手順に従って問題を再現する必要はありません。
短所：メモリダンプは非常に大きいため、AdPlus / procdumpをプロセスにアタッチする必要があります。
2。アスペクト指向プログラミング。
プロの：これはおそらく、アプリケーションのすべてのメソッドにコードを記述せずに、任意のメソッドから呼び出しスタックのサイズをチェックするコードを実装する最も簡単な方法です。多数の AOP Frameworks 呼び出しの前後にインターセプトできます。
スタックオーバーフローの原因となっているメソッドについて説明します。
アプリケーションのすべてのメソッドの入り口と出口で StackTrace（）。FrameCount を確認できます。
短所：パフォーマンスに影響があります。すべてのメソッドでフックがILに埋め込まれているため、実際に「非アクティブ化」することはできません。それを。
開発環境のツールセットによって多少異なります。
3。ユーザーアクティビティの記録。
一週間前、私は問題を再現するのが難しいいくつかを追い詰めようとしていました。このQA ユーザーアクティビティロギング、テレメトリ（および変数）を投稿しましたグローバル例外ハンドラで）。私が思いついた結論は、未処理の例外が発生したときにデバッガーで問題を再現する方法を確認するための非常に単純なユーザーアクションロガーでした。
プロの：自由にオン/オフを切り替えることができます（つまり、イベントにサブスクライブします）。
ユーザーアクションの追跡には、すべてのメソッドをインターセプトする必要はありません。
メソッドがサブスクライブされているイベントの数を数えることができます。 AOPよりもはるかに簡単。
ログファイルは比較的小さく、どのアクションに集中するかn
アプリケーションが3Dパーティコード（Xslスクリプト内）に依存している場合、最初にそれらのバグから防御するかどうかを決定する必要があります。 本当に防御したい場合は、別のAppDomainで外部エラーが発生しやすいロジックを実行する必要があると思います。 StackOverflowExceptionをキャッチするのはよくありません。
質問もチェックしてください。
今日、stackoverflowがあり、あなたの投稿のいくつかを読んで、Garbage Collecterを手伝うことにしました。
以前は次のような無限ループに近かった：
class Foo
{
public Foo()
{
Go();
}
public void Go()
{
for (float i = float.MinValue; i < float.MaxValue; i+= 0.000000000000001f)
{
byte[] b = new byte[1]; // Causes stackoverflow
}
}
}
代わりに、リソースを次のようにスコープ外で実行させます：
class Foo
{
public Foo()
{
GoHelper();
}
public void GoHelper()
{
for (float i = float.MinValue; i < float.MaxValue; i+= 0.000000000000001f)
{
Go();
}
}
public void Go()
{
byte[] b = new byte[1]; // Will get cleaned by GC
} // right now
}
それは私のために働いた、それが誰かを助けることを願っています。
.NET 4.0では、System.Runtime.ExceptionServicesの HandleProcessCorruptedStateExceptions 属性をtry / catchブロックを含むメソッドに追加できます。これは本当にうまくいきました！推奨されないかもしれませんが、動作します。
using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.ExceptionServices;
namespace ExceptionCatching
{
public class Test
{
public void StackOverflow()
{
StackOverflow();
}
public void CustomException()
{
throw new Exception();
}
public unsafe void AccessViolation()
{
byte b = *(byte*)(8762765876);
}
}
class Program
{
[HandleProcessCorruptedStateExceptions]
static void Main(string[] args)
{
Test test = new Test();
try {
//test.StackOverflow();
test.AccessViolation();
//test.CustomException();
}
catch
{
Console.WriteLine("Caught.");
}
Console.WriteLine("End of program");
}
}
}
@WilliamJockusch、私があなたの懸念を正しく理解していれば、（数学的観点から）停止の問題。これを解決するには、超再帰アルゴリズム（試行錯誤の述語）または可能なマシン hypercompute （例はフォローセクション-プレビューとして利用可能-この本）。
実用的な観点から、知っておく必要があります：
- 指定した時間に残っているスタックメモリの量
- 特定の出力のために、指定された時間に再帰メソッドが必要とするスタックメモリの量。
現在のマシンでは、このデータはマルチタスクのために非常に変更可能であり、タスクを実行するソフトウェアを聞いたことがないことに注意してください。
不明な点がある場合は教えてください。
見たところ、別のプロセスを開始する以外に、 StackOverflowException を処理する方法はないようです。他の人が尋ねる前に、 AppDomain を使用しようとしましたが、うまくいきませんでした：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
namespace StackOverflowExceptionAppDomainTest
{
class Program
{
static void recrusiveAlgorithm()
{
recrusiveAlgorithm();
}
static void Main(string[] args)
{
if(args.Length>0&&args[0]=="--child")
{
recrusiveAlgorithm();
}
else
{
var domain = AppDomain.CreateDomain("Child domain to test StackOverflowException in.");
domain.ExecuteAssembly(Assembly.GetEntryAssembly().CodeBase, new[] { "--child" });
domain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) =>
{
Console.WriteLine("Detected unhandled exception: " + e.ExceptionObject.ToString());
};
while (true)
{
Console.WriteLine("*");
Thread.Sleep(1000);
}
}
}
}
}
ただし、分離プロセスソリューションを使用することになった場合は、 Process.Exited および Process.StandardOutput を使用して、エラーを自分で処理することをお勧めします。ユーザーの操作性が向上します。
Environment.StackTrace を呼び出すたびにこのプロパティを読み取ることができ、スタックトレースが事前に設定した特定のしきい値を超えた場合、関数を返すことができます。
一部の再帰関数をループに置き換えることもお勧めします。
