private static void Anonimowa(object sender, ContractFailedEventArgs e)
{
string messgae = e.FailureKind + ": " + e.Message;
Console.WriteLine(messgae);
e.SetUnwind();
}
private static void FailFastContractViolationsCheck(object sender, ContractFailedEventArgs args)
{
Console.WriteLine("Contract exception occurred. Waiting for {0} seconds then killing the app in fail fast way!", s_failFastWaitTime.TotalSeconds);
Console.WriteLine("Condition: " + args.Condition);
Console.WriteLine("Message: " + args.Message);
lock (s_syncLock)
{
s_testRunnerActiveSinceContractFailure = false;
Analysis.IgnoreResult(
Task.Run(
async() =>
{
// Wait two seconds then fail if test runner has not reported activity in
// that time period.
await Task.Delay(s_failFastWaitTime);
lock (s_syncLock)
{
if (!s_testRunnerActiveSinceContractFailure)
{
var msg = "MS Test can't deal with exception serialization. Killing the app in fail fast way!";
ExceptionHandling.OnFatalException(null, msg);
}
}
}),
"Fire and forget is okay here"
);
}
}
private void HandleContractFailed(object sender, ContractFailedEventArgs args)
{
if (DesignerProperties.GetIsInDesignMode(this))
{
args.SetHandled();
}
}
static partial void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException, ref string resultFailureMessage)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, failureKind), nameof(failureKind));
}
Contract.EndContractBlock();
string returnValue;
String displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup...
ContractFailedEventArgs eventArgs = null; // In case of OOM.
#if FEATURE_RELIABILITY_CONTRACTS
System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
#endif
try
{
displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText);
EventHandler <ContractFailedEventArgs> contractFailedEventLocal = contractFailedEvent;
if (contractFailedEventLocal != null)
{
eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException);
foreach (EventHandler <ContractFailedEventArgs> handler in contractFailedEventLocal.GetInvocationList())
{
try
{
handler(null, eventArgs);
}
catch (Exception e)
{
eventArgs.thrownDuringHandler = e;
eventArgs.SetUnwind();
}
}
if (eventArgs.Unwind)
{
// unwind
if (innerException == null)
{
innerException = eventArgs.thrownDuringHandler;
}
throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException);
}
}
}
finally
{
if (eventArgs != null && eventArgs.Handled)
{
returnValue = null; // handled
}
else
{
returnValue = displayMessage;
}
}
resultFailureMessage = returnValue;
}
static partial void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException, ref string resultFailureMessage)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException("failureKind is not in range", "failureKind");
}
Contract.EndContractBlock();
String displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup...
ContractFailedEventArgs eventArgs = null; // In case of OOM.
string returnValue;
#if FEATURE_RELIABILITY_CONTRACTS
// on ASP.NET with medium trust, this causes a security exception.
//System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
#endif
try
{
displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText);
if (contractFailedEvent != null)
{
eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException);
foreach (EventHandler <ContractFailedEventArgs> handler in contractFailedEvent.GetInvocationList())
{
try
{
handler(null, eventArgs);
}
catch (Exception e)
{
eventArgs.thrownDuringHandler = e;
eventArgs.SetUnwindNoDemand(); // avoid security exception on asp.net
}
}
if (eventArgs.Unwind)
{
// unwind
if (innerException == null)
{
innerException = eventArgs.thrownDuringHandler;
}
throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException);
}
}
}
finally
{
if (eventArgs != null && eventArgs.Handled)
{
returnValue = null; // handled
}
else
{
returnValue = displayMessage;
}
}
resultFailureMessage = returnValue;
}
private static void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException, ref string resultFailureMessage)
{
string str2;
if ((failureKind < ContractFailureKind.Precondition) || (failureKind > ContractFailureKind.Assume))
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { failureKind }), "failureKind");
}
string message = "contract failed.";
ContractFailedEventArgs e = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
message = GetDisplayMessage(failureKind, userMessage, conditionText);
if (contractFailedEvent != null)
{
e = new ContractFailedEventArgs(failureKind, message, conditionText, innerException);
foreach (EventHandler <ContractFailedEventArgs> handler in contractFailedEvent.GetInvocationList())
{
try
{
handler(null, e);
}
catch (Exception exception)
{
e.thrownDuringHandler = exception;
e.SetUnwind();
}
}
if (e.Unwind)
{
if (Environment.IsCLRHosted)
{
TriggerCodeContractEscalationPolicy(failureKind, message, conditionText, innerException);
}
if (innerException == null)
{
innerException = e.thrownDuringHandler;
}
throw new ContractException(failureKind, message, userMessage, conditionText, innerException);
}
}
}
finally
{
if ((e != null) && e.Handled)
{
str2 = null;
}
else
{
str2 = message;
}
}
resultFailureMessage = str2;
}
public static string?RaiseContractFailedEvent(ContractFailureKind failureKind, string?userMessage, string?conditionText, Exception?innerException)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, failureKind), nameof(failureKind));
}
string?returnValue;
string displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup...
ContractFailedEventArgs?eventArgs = null; // In case of OOM.
try
{
displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText);
EventHandler <ContractFailedEventArgs> contractFailedEventLocal = InternalContractFailed;
if (contractFailedEventLocal != null)
{
eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException);
foreach (EventHandler <ContractFailedEventArgs> handler in contractFailedEventLocal.GetInvocationList())
{
try
{
handler(null, eventArgs);
}
catch (Exception e)
{
eventArgs.thrownDuringHandler = e;
eventArgs.SetUnwind();
}
}
if (eventArgs.Unwind)
{
// unwind
if (innerException == null)
{
innerException = eventArgs.thrownDuringHandler;
}
throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException);
}
}
}
finally
{
if (eventArgs != null && eventArgs.Handled)
{
returnValue = null; // handled
}
else
{
returnValue = displayMessage;
}
}
return(returnValue);
}
private void OnContractFailed(object sender, ContractFailedEventArgs e)
{
this.logger.Fatal("Contract failed : {0}", e.Condition);
if (e.OriginalException != null)
{
this.HandleCrashException(e.OriginalException);
}
else
{
this.logger.Fatal(string.Format(" Stack Trace:\r\n{0}", Environment.StackTrace));
}
e.SetHandled();
}
private static void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException, ref string resultFailureMessage)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (object)failureKind), "failureKind");
}
string str1 = "contract failed.";
ContractFailedEventArgs e = (ContractFailedEventArgs)null;
RuntimeHelpers.PrepareConstrainedRegions();
string str2;
try
{
str1 = ContractHelper.GetDisplayMessage(failureKind, userMessage, conditionText);
EventHandler <ContractFailedEventArgs> eventHandler = ContractHelper.contractFailedEvent;
if (eventHandler != null)
{
e = new ContractFailedEventArgs(failureKind, str1, conditionText, innerException);
foreach (EventHandler <ContractFailedEventArgs> invocation in eventHandler.GetInvocationList())
{
try
{
invocation((object)null, e);
}
catch (Exception ex)
{
e.thrownDuringHandler = ex;
e.SetUnwind();
}
}
if (e.Unwind)
{
if (Environment.IsCLRHosted)
{
ContractHelper.TriggerCodeContractEscalationPolicy(failureKind, str1, conditionText, innerException);
}
if (innerException == null)
{
innerException = e.thrownDuringHandler;
}
throw new ContractException(failureKind, str1, userMessage, conditionText, innerException);
}
}
}
finally
{
str2 = e == null || !e.Handled ? str1 : (string)null;
}
resultFailureMessage = str2;
}
private void OnContractFailed(object sender, ContractFailedEventArgs e)
{
// compiler might be in a weird state, start over.
// but which compiler is it?
string reason = e.Message;
if (e.OriginalException != null && e.OriginalException.Message != reason)
{
reason += ". " + e.OriginalException.Message;
if (e.OriginalException.InnerException != null)
{
reason += ". " + e.OriginalException.InnerException.Message;
}
}
throw new Exception(reason);
}
public static void ContractFailureHandler(Object obj, ContractFailedEventArgs args)
{
throw new ContractFailedException();
}
private void Contract_ContractFailed(object sender, ContractFailedEventArgs e)
{
throw new NotImplementedException();
}
private static void contractFailedEvent(object sender, ContractFailedEventArgs e)
{
e.SetUnwind();
throw new Exception(e.Message);
}
public static string RaiseContractFailedEvent (ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException)
{
StringBuilder msg = new StringBuilder (60);
switch (failureKind) {
case ContractFailureKind.Assert:
msg.Append ("Assertion failed");
break;
case ContractFailureKind.Assume:
msg.Append ("Assumption failed");
break;
case ContractFailureKind.Invariant:
msg.Append ("Invariant failed");
break;
case ContractFailureKind.Postcondition:
msg.Append ("Postcondition failed");
break;
case ContractFailureKind.PostconditionOnException:
msg.Append ("Postcondition failed after throwing an exception");
break;
case ContractFailureKind.Precondition:
msg.Append ("Precondition failed");
break;
default:
throw new NotSupportedException ("Not supported: " + failureKind);
}
if (conditionText != null) {
msg.Append (": ");
msg.Append (conditionText);
} else {
msg.Append ('.');
}
if (userMessage != null) {
msg.Append (" ");
msg.Append (userMessage);
}
string msgString = msg.ToString ();
Exception handlerException = null;
bool unwind = false, handled = false;
var contractFailed = Contract.InternalContractFailedEvent;
if (contractFailed != null) {
// Execute all event handlers
var handlers = contractFailed.GetInvocationList ();
var e = new ContractFailedEventArgs (failureKind, msgString, conditionText, innerException);
foreach (var handler in handlers) {
try {
handler.DynamicInvoke (null, e);
} catch (Exception ex) {
e.SetUnwind ();
// If multiple handlers throw an exception then the specification states that it
// is undetermined which one becomes the InnerException.
handlerException = ex.InnerException;
}
}
unwind = e.Unwind;
handled = e.Handled;
}
if (unwind) {
Exception ex = innerException ?? handlerException;
throw new ContractException (msgString, failureKind, conditionText, userMessage, ex);
}
return handled ? null : msgString;
}
internal static void EventHandler(object sender, ContractFailedEventArgs args)
{
_queue.Enqueue(args.Message);
}
public static string RaiseContractFailedEvent(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException)
{
StringBuilder msg = new StringBuilder(60);
switch (failureKind)
{
case ContractFailureKind.Assert:
msg.Append("Assertion failed");
break;
case ContractFailureKind.Assume:
msg.Append("Assumption failed");
break;
case ContractFailureKind.Invariant:
msg.Append("Invariant failed");
break;
case ContractFailureKind.Postcondition:
msg.Append("Postcondition failed");
break;
case ContractFailureKind.PostconditionOnException:
msg.Append("Postcondition failed after throwing an exception");
break;
case ContractFailureKind.Precondition:
msg.Append("Precondition failed");
break;
default:
throw new NotSupportedException("Not supported: " + failureKind);
}
if (conditionText != null)
{
msg.Append(": ");
msg.Append(conditionText);
}
else
{
msg.Append('.');
}
if (userMessage != null)
{
msg.Append(" ");
msg.Append(userMessage);
}
string msgString = msg.ToString();
Exception handlerException = null;
bool unwind = false, handled = false;
var contractFailed = Contract.InternalContractFailedEvent;
if (contractFailed != null)
{
// Execute all event handlers
var handlers = contractFailed.GetInvocationList();
var e = new ContractFailedEventArgs(failureKind, msgString, conditionText, innerException);
foreach (var handler in handlers)
{
try {
handler.DynamicInvoke(null, e);
} catch (Exception ex) {
e.SetUnwind();
// If multiple handlers throw an exception then the specification states that it
// is undetermined which one becomes the InnerException.
handlerException = ex.InnerException;
}
}
unwind = e.Unwind;
handled = e.Handled;
}
if (unwind)
{
Exception ex = innerException ?? handlerException;
throw new ContractException(msgString, failureKind, conditionText, userMessage, ex);
}
return(handled ? null : msgString);
}
static partial void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException, ref string resultFailureMessage)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", failureKind), "failureKind");
Contract.EndContractBlock();
String displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup...
ContractFailedEventArgs eventArgs = null; // In case of OOM.
string returnValue;
#if FEATURE_RELIABILITY_CONTRACTS
System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
#endif
try
{
displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText);
if (contractFailedEvent != null)
{
eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException);
foreach (EventHandler<ContractFailedEventArgs> handler in contractFailedEvent.GetInvocationList())
{
try
{
handler(null, eventArgs);
}
catch (Exception e)
{
eventArgs.thrownDuringHandler = e;
eventArgs.SetUnwind();
}
}
if (eventArgs.Unwind)
{
if (Environment.IsCLRHosted)
TriggerCodeContractEscalationPolicy(failureKind, displayMessage, conditionText, innerException);
// unwind
if (innerException == null) { innerException = eventArgs.thrownDuringHandler; }
throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException);
}
}
}
finally
{
if (eventArgs != null && eventArgs.Handled)
{
returnValue = null; // handled
}
else
{
returnValue = displayMessage;
}
}
resultFailureMessage = returnValue;
}
static void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, string userMessage,
string conditionText, Exception innerException, ref string resultFailureMessage)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException(string.Format("Invalid enum value: {0}", failureKind), "failureKind");
}
Contract.EndContractBlock();
string returnValue;
var displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup...
ContractFailedEventArgs eventArgs = null; // In case of OOM.
RuntimeHelpers.PrepareConstrainedRegions();
try
{
displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText);
var contractFailedEventLocal = _contractFailedEvent;
if (contractFailedEventLocal != null)
{
eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException);
foreach (var @delegate in contractFailedEventLocal.GetInvocationList())
{
var handler = (EventHandler <ContractFailedEventArgs>)@delegate;
try
{
handler(null, eventArgs);
}
catch (Exception e)
{
#if NET35
eventArgs.ThrownDuringHandler = e;
#else
GC.KeepAlive(e);
#endif
eventArgs.SetUnwind();
}
}
if (eventArgs.Unwind)
{
#if NET35
// unwind
if (innerException == null)
{
innerException = eventArgs.ThrownDuringHandler;
}
#endif
throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException);
}
}
}
finally
{
if (eventArgs != null && eventArgs.Handled)
{
returnValue = null; // handled
}
else
{
returnValue = displayMessage;
}
}
resultFailureMessage = returnValue;
}
static partial void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException, ref string resultFailureMessage)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
throw new ArgumentException("failureKind is not in range", "failureKind");
Contract.EndContractBlock();
String displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup...
ContractFailedEventArgs eventArgs = null; // In case of OOM.
string returnValue;
#if FEATURE_RELIABILITY_CONTRACTS
// on ASP.NET with medium trust, this causes a security exception.
//System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
#endif
try
{
displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText);
if (contractFailedEvent != null)
{
eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException);
foreach (EventHandler<ContractFailedEventArgs> handler in contractFailedEvent.GetInvocationList())
{
try
{
handler(null, eventArgs);
}
catch (Exception e)
{
eventArgs.thrownDuringHandler = e;
eventArgs.SetUnwindNoDemand(); // avoid security exception on asp.net
}
}
if (eventArgs.Unwind)
{
// unwind
if (innerException == null) { innerException = eventArgs.thrownDuringHandler; }
throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException);
}
}
}
finally
{
if (eventArgs != null && eventArgs.Handled)
{
returnValue = null; // handled
}
else
{
returnValue = displayMessage;
}
}
resultFailureMessage = returnValue;
}
/// <summary>
/// EventHandler
/// </summary>
/// <param name="sender">always null</param>
/// <param name="args">holds the assertion being triggered</param>
internal static void EventHandler(object sender, ContractFailedEventArgs args)
{
var index = CALLING_FRAME;
var stackTrace = new StackTrace(index);
var frames = stackTrace.GetFrames();
Contract.Assume(null != frames);
// wait for first frame that is not a System / native frame
var frame = default(StackFrame);
var declaringType = default(Type);
for (index = CALLING_FRAME; index < frames.Length; index++)
{
var currentFrame = frames[index];
declaringType = currentFrame.GetMethod().DeclaringType;
if (null == declaringType)
{
continue;
}
if (declaringType.FullName.StartsWith(SYSTEM_NAMESPACE))
{
continue;
}
frame = currentFrame;
break;
}
// very unlikely - but maybe this was a .NET all internal contract exception
if (null == frame)
{
return;
}
//// extract method name that caused the assertion and the traceSource
//var traceSource = _traceSources.GetOrAdd(declaringType.Assembly.FullName, assembly => default(TraceSource));
//if (null == traceSource)
//{
// return;
//}
var traceSource = default(TraceSource);
var methodName = string.Format(NAMESPACE_CLASS_METHOD_FORMAT, declaringType.FullName, frame.GetMethod().Name);
var message = new StringBuilder();
for (var c = index; c < frames.Length; c++)
{
frame = frames[c];
var method = frame.GetMethod();
declaringType = method.DeclaringType;
if (null != declaringType)
{
if (null == traceSource)
{
traceSource = _traceSources.GetOrAdd(declaringType.Assembly.FullName, assembly => default(TraceSource));
}
if (null != traceSource)
{
if (!traceSource.Switch.ShouldTrace(TraceEventType.Error))
{
return;
}
// for Pre and Post conditions we just log the message
if (ContractFailureKind.Precondition == args.FailureKind ||
ContractFailureKind.Postcondition == args.FailureKind)
{
traceSource.TraceEvent(TraceEventType.Error, EVENT_ID, METHOD_MESSAGE_FORMAT, methodName, args.Message);
return;
}
}
if (DO_EXECUTE.Equals(method.Name) &&
SYSTEM_MANAGEMENT_AUTOMATION_COMMANDPROCESSORBASE.Equals(declaringType.ToString()))
{
break;
}
}
message.AppendLine();
message.AppendFormat(STACK_FRAME_AT_FORMAT, declaringType, method.Name);
}
if (null == traceSource)
{
return;
}
traceSource.TraceEvent(TraceEventType.Error, EVENT_ID, METHOD_MESSAGE_AND_STACKTRACE_FORMAT, methodName, args.Message, message);
}
private static void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException, ref string resultFailureMessage)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[]
{
failureKind
}), "failureKind");
}
string text = "contract failed.";
ContractFailedEventArgs contractFailedEventArgs = null;
RuntimeHelpers.PrepareConstrainedRegions();
string text2;
try
{
text = ContractHelper.GetDisplayMessage(failureKind, userMessage, conditionText);
EventHandler <ContractFailedEventArgs> eventHandler = ContractHelper.contractFailedEvent;
if (eventHandler != null)
{
contractFailedEventArgs = new ContractFailedEventArgs(failureKind, text, conditionText, innerException);
foreach (EventHandler <ContractFailedEventArgs> eventHandler2 in eventHandler.GetInvocationList())
{
try
{
eventHandler2(null, contractFailedEventArgs);
}
catch (Exception thrownDuringHandler)
{
contractFailedEventArgs.thrownDuringHandler = thrownDuringHandler;
contractFailedEventArgs.SetUnwind();
}
}
if (contractFailedEventArgs.Unwind)
{
if (Environment.IsCLRHosted)
{
ContractHelper.TriggerCodeContractEscalationPolicy(failureKind, text, conditionText, innerException);
}
if (innerException == null)
{
innerException = contractFailedEventArgs.thrownDuringHandler;
}
throw new ContractException(failureKind, text, userMessage, conditionText, innerException);
}
}
}
finally
{
if (contractFailedEventArgs != null && contractFailedEventArgs.Handled)
{
text2 = null;
}
else
{
text2 = text;
}
}
resultFailureMessage = text2;
}
static void HandleFailure(object sender, ContractFailedEventArgs args)
{
Console.WriteLine("{0}: {1} {2}", args.FailureKind,
args.Condition, args.Message);
args.SetHandled();
}
static void Contract_ContractFailed(object sender, ContractFailedEventArgs e)
{
Console.WriteLine("No se pudo asumir algo: " + e.Condition);
e.SetHandled( );
Console.ReadKey( );
}
private static void Contract_ContractFailed(object sender, ContractFailedEventArgs e)
{
e.SetHandled();
// Assert.Fail("{0}: {1} {2}", e.FailureKind, e.Message, e.Condition);
}
public static string RaiseContractFailedEvent(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, failureKind), nameof(failureKind));
}
Contract.EndContractBlock();
string returnValue;
string displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup...
#if !FEATURE_CORECLR
ContractFailedEventArgs eventArgs = null; // In case of OOM.
#endif // !FEATURE_CORECLR
#if FEATURE_RELIABILITY_CONTRACTS
System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
#endif
try
{
displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText);
#if !FEATURE_CORECLR
if (s_contractFailedEvent != null)
{
eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException);
foreach (EventHandler <ContractFailedEventArgs> handler in s_contractFailedEvent.GetInvocationList())
{
try
{
handler(null, eventArgs);
}
catch (Exception e)
{
eventArgs.thrownDuringHandler = e;
eventArgs.SetUnwind();
}
}
if (eventArgs.Unwind)
{
//if (Environment.IsCLRHosted)
// TriggerCodeContractEscalationPolicy(failureKind, displayMessage, conditionText, innerException);
// unwind
if (innerException == null)
{
innerException = eventArgs.thrownDuringHandler;
}
throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException);
}
}
#endif // !FEATURE_CORECLR
}
finally
{
#if !FEATURE_CORECLR
if (eventArgs != null && eventArgs.Handled)
{
returnValue = null; // handled
}
else
#endif // !FEATURE_CORECLR
{
returnValue = displayMessage;
}
}
return(returnValue);
}
