public ContractFailedEventArgs(ContractFailureKind failureKind, string message, string condition, Exception originalException)
{
this._failureKind = failureKind;
this._message = message;
this._condition = condition;
this._originalException = originalException;
}
private ContractException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
: base(info, context)
{
_Kind = (ContractFailureKind)info.GetInt32("Kind");
_UserMessage = info.GetString("UserMessage");
_Condition = info.GetString("Condition");
}
public virtual bool OnContractFailure(String stackTrace, ContractFailureKind contractFailureKind, String displayMessage, String userMessage, String conditionText, Exception innerException)
{
Debug.WriteLine("Assertion failed: " + (displayMessage == null ? "" : displayMessage));
if (Debugger.IsAttached)
Debugger.Break();
return false;
}
private static string KindToString(ContractFailureKind kind)
{
var kindString = "unknown";
switch (kind)
{
case ContractFailureKind.Assert:
kindString = "Contract.Assert";
break;
case ContractFailureKind.Assume:
kindString = "Contract.Assume";
break;
case ContractFailureKind.Invariant:
kindString = "Contract.Invariant";
break;
case ContractFailureKind.Postcondition:
kindString = "Contract.Postcondition";
break;
case ContractFailureKind.PostconditionOnException:
kindString = "Contract.PostconditionOnException";
break;
case ContractFailureKind.Precondition:
kindString = "Contract.Precondition";
break;
}
return kindString;
}
static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind)
{
if (_assertingMustUseRewriter)
System.Diagnostics.Assert.Fail("Asserting that we must use the rewriter went reentrant.", "Didn't rewrite this mscorlib?");
_assertingMustUseRewriter = true;
// For better diagnostics, report which assembly is at fault. Walk up stack and
// find the first non-mscorlib assembly.
Assembly thisAssembly = typeof(Contract).Assembly; // In case we refactor mscorlib, use Contract class instead of Object.
StackTrace stack = new StackTrace();
Assembly probablyNotRewritten = null;
for (int i = 0; i < stack.FrameCount; i++)
{
Assembly caller = stack.GetFrame(i).GetMethod().DeclaringType.Assembly;
if (caller != thisAssembly)
{
probablyNotRewritten = caller;
break;
}
}
if (probablyNotRewritten == null)
probablyNotRewritten = thisAssembly;
String simpleName = probablyNotRewritten.GetName().Name;
System.Runtime.CompilerServices.ContractHelper.TriggerFailure(kind, Environment.GetResourceString("MustUseCCRewrite", contractKind, simpleName), null, null, null);
_assertingMustUseRewriter = false;
}
/// <summary>
/// This method is used internally to trigger a failure indicating to the "programmer" that he is using the interface incorrectly.
/// It is NEVER used to indicate failure of actual contracts at runtime.
/// </summary>
#if FEATURE_UNTRUSTED_CALLERS
#endif
static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind)
{
//TODO: Implement CodeContract failure mechanics including enabling CCIRewrite
if (t_assertingMustUseRewriter)
{
System.Diagnostics.Debug.Assert(false, "Asserting that we must use the rewriter went reentrant. Didn't rewrite this System.Private.CoreLib?");
return;
}
t_assertingMustUseRewriter = true;
//// For better diagnostics, report which assembly is at fault. Walk up stack and
//// find the first non-mscorlib assembly.
//Assembly thisAssembly = typeof(Contract).Assembly; // In case we refactor mscorlib, use Contract class instead of Object.
//StackTrace stack = new StackTrace();
//Assembly probablyNotRewritten = null;
//for (int i = 0; i < stack.FrameCount; i++)
//{
// Assembly caller = stack.GetFrame(i).GetMethod().DeclaringType.Assembly;
// if (caller != thisAssembly)
// {
// probablyNotRewritten = caller;
// break;
// }
//}
//if (probablyNotRewritten == null)
// probablyNotRewritten = thisAssembly;
//String simpleName = probablyNotRewritten.GetName().Name;
String simpleName = "System.Private.CoreLib";
System.Runtime.CompilerServices.ContractHelper.TriggerFailure(kind, SR.Format(SR.MustUseCCRewrite, contractKind, simpleName), null, null, null);
t_assertingMustUseRewriter = false;
}
// internal Exception thrownDuringHandler;
public ContractFailedEventArgs(ContractFailureKind failureKind, String message, String condition, Exception originalException)
{
Contract.Requires(originalException == null || failureKind == ContractFailureKind.PostconditionOnException);
_failureKind = failureKind;
_message = message;
_condition = condition;
_originalException = originalException;
}
public ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException)
: base(failure, innerException)
{
HResult = Runtime.CompilerServices.ContractHelper.COR_E_CODECONTRACTFAILED;
_Kind = kind;
_UserMessage = userMessage;
_Condition = condition;
}
internal ContractException (string failure, ContractFailureKind kind, string condition, string userMessage, Exception innerException)
: base (failure, innerException)
{
this.Failure = failure;
this.Kind = kind;
this.Condition = condition;
this.UserMessage = userMessage;
}
public ContractFailedEventArgs (ContractFailureKind failureKind, string message, string condition, Exception originalException)
{
Condition = condition;
FailureKind = failureKind;
Handled = false;
Unwind = true;
Message = message;
OriginalException = originalException;
}
public ContractFailedEventArgs (ContractFailureKind failureKind, string message, string condition, Exception originalException)
{
Condition = condition;
FailureKind = failureKind;
Handled = false;
Unwind = false; // MS docs are incorrect - this should default to false.
Message = message;
OriginalException = originalException;
}
/// <summary>
/// This method is used internally to trigger a failure indicating to the "programmer" that he is using the interface incorrectly.
/// It is NEVER used to indicate failure of actual contracts at runtime.
/// </summary>
static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind)
{
if (_assertingMustUseRewriter)
System.Diagnostics.Assert.Fail("Asserting that we must use the rewriter went reentrant.", "Didn't rewrite this mscorlib?");
_assertingMustUseRewriter = true;
// @
Internal.ContractHelper.TriggerFailure(kind, "Must use the rewriter when using Contract." + contractKind, null, null, null);
_assertingMustUseRewriter = false;
}
public ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException)
: base(failure, innerException) {
this.m_data._Kind = kind;
this.m_data._UserMessage = userMessage;
this.m_data._Condition = condition;
SerializeObjectState += delegate(object exception, SafeSerializationEventArgs eventArgs) {
// This is fired when the exception is being serialized and asks
// the exception to provide a serializable chunk of state to save
// with the rest of the exception.
eventArgs.AddSerializedState(m_data);
};
}
private static string GetDisplayMessage(ContractFailureKind failureKind, string userMessage, string conditionText)
{
string key = null;
switch (failureKind)
{
case ContractFailureKind.Precondition:
key = "PreconditionFailed";
break;
case ContractFailureKind.Postcondition:
key = "PostconditionFailed";
break;
case ContractFailureKind.PostconditionOnException:
key = "PostconditionOnExceptionFailed";
break;
case ContractFailureKind.Invariant:
key = "InvariantFailed";
break;
case ContractFailureKind.Assert:
key = "AssertionFailed";
break;
case ContractFailureKind.Assume:
key = "AssumptionFailed";
break;
default:
Contract.Assume(false, "Unreachable code");
key = "AssumptionFailed";
break;
}
if (!string.IsNullOrEmpty(conditionText))
{
key = key + "_Cnd";
}
string runtimeResourceString = Environment.GetRuntimeResourceString(key);
if (!string.IsNullOrEmpty(conditionText))
{
if (!string.IsNullOrEmpty(userMessage))
{
return (string.Format(CultureInfo.CurrentUICulture, runtimeResourceString, new object[] { conditionText }) + " " + userMessage);
}
return string.Format(CultureInfo.CurrentUICulture, runtimeResourceString, new object[] { conditionText });
}
if (!string.IsNullOrEmpty(userMessage))
{
return (runtimeResourceString + " " + userMessage);
}
return runtimeResourceString;
}
public static string RaiseContractFailedEvent(ContractFailureKind kind, string userMessage, string conditionText, Exception innerException)
{
CountFailure(kind);
#if DEBUG
var kindString = KindToString(kind);
var message = String.Format("{0} failed: {1} {2}", kindString, conditionText, userMessage);
Console.WriteLine(message);
return message;
#else
// handled
return null;
#endif
}
static partial void ReportFailure(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", failureKind), "failureKind");
Contract.EndContractBlock();
// displayMessage == null means: yes we handled it. Otherwise it is the localized failure message
var displayMessage = Internal.ContractHelper.RaiseContractFailedEvent(failureKind, userMessage, conditionText, innerException);
if (displayMessage == null) return;
Internal.ContractHelper.TriggerFailure(failureKind, displayMessage, userMessage, conditionText, innerException);
}
private static void ReportFailure(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException)
{
if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
{
throw new ArgumentException(string.Format("Invalid enum value: {0}", failureKind), "failureKind");
}
EndContractBlock();
// displayMessage == null means: yes we handled it. Otherwise it is the localized failure message
var displayMessage = ContractHelper.RaiseContractFailedEvent(failureKind, userMessage, conditionText, innerException);
if (displayMessage == null)
{
return;
}
ContractHelper.TriggerFailure(failureKind, displayMessage, userMessage, conditionText, innerException);
}
private static String GetDisplayMessage(ContractFailureKind failureKind, String userMessage, String conditionText)
{
// Well-formatted English messages will take one of four forms. A sentence ending in
// either a period or a colon, the condition string, then the message tacked
// on to the end with two spaces in front.
// Note that both the conditionText and userMessage may be null. Also,
// on Silverlight we may not be able to look up a friendly string for the
// error message. Let's leverage Silverlight's default error message there.
String failureMessage = GetFailureMessage(failureKind, conditionText);
// Now add in the user message, if present.
if (!String.IsNullOrEmpty(userMessage))
{
return(failureMessage + " " + userMessage);
}
else
{
return(failureMessage);
}
}
private static void AssertMustUseRewriter(ContractFailureKind kind, string contractKind)
{
if (_assertingMustUseRewriter)
{
ContractHelperEx.Fail("Asserting that we must use the rewriter went reentrant."); // Didn't rewrite this mscorlib?
}
_assertingMustUseRewriter = true;
// For better diagnostics, report which assembly is at fault. Walk up stack and
// find the first non-mscorlib assembly.
var thisAssembly = typeof(Contract).Assembly; // In case we refactor mscorlib, use Contract class instead of Object.
var stack = new StackTrace();
Assembly probablyNotRewritten = null;
for (var i = 0; i < stack.FrameCount; i++)
{
var declaringType = stack.GetFrame(i).GetMethod().DeclaringType;
if (declaringType == null)
{
// Not standard method info - ignoring
continue;
}
var caller = declaringType.Assembly;
if (thisAssembly.Equals(caller))
{
continue;
}
probablyNotRewritten = caller;
break;
}
if (probablyNotRewritten == null)
{
probablyNotRewritten = thisAssembly;
}
var simpleName = probablyNotRewritten.GetName().Name;
ContractHelper.TriggerFailure(kind, string.Format("The code has not been rewriten. ContractKind: {0} - Source: {1}", contractKind, simpleName), null, null, null);
_assertingMustUseRewriter = false;
}
static partial void TriggerFailureImplementation(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException)
{
// If we're here, our intent is to pop up a dialog box (if we can). For developers
// interacting live with a debugger, this is a good experience. For Silverlight
// hosted in Internet Explorer, the assert window is great. If we cannot
// pop up a dialog box, throw an exception (consider a library compiled with
// "Assert On Failure" but used in a process that can't pop up asserts, like an
// NT Service). For the CLR hosted by server apps like SQL or Exchange, we should
// trigger escalation policy.
//#if !FEATURE_CORECLR
// if (Environment.IsCLRHosted)
// {
// TriggerCodeContractEscalationPolicy(kind, displayMessage, conditionText, innerException);
// // Hosts like SQL may choose to abort the thread, so we will not get here in all cases.
// // But if the host's chosen action was to throw an exception, we should throw an exception
// // here (which is easier to do in managed code with the right parameters).
// throw new ContractException(kind, displayMessage, userMessage, conditionText, innerException);
// }
//#endif // !FEATURE_CORECLR
//TODO: Implement CodeContract failure mechanics including enabling CCIRewrite
String stackTrace = null; //@todo: Any reasonable way to get a stack trace here?
bool userSelectedIgnore = DeveloperExperience.Default.OnContractFailure(stackTrace, kind, displayMessage, userMessage, conditionText, innerException);
if (userSelectedIgnore)
{
return;
}
//if (!Environment.UserInteractive) {
throw new ContractException(kind, displayMessage, userMessage, conditionText, innerException);
//}
//// May need to rethink Assert.Fail w/ TaskDialogIndirect as a model. Window title. Main instruction. Content. Expanded info.
//// Optional info like string for collapsed text vs. expanded text.
//String windowTitle = SR.Format(GetResourceNameForFailure(kind));
//const int numStackFramesToSkip = 2; // To make stack traces easier to read
//System.Diagnostics.Debug.Assert(conditionText, displayMessage, windowTitle, COR_E_CODECONTRACTFAILED, StackTrace.TraceFormat.Normal, numStackFramesToSkip);
// If we got here, the user selected Ignore. Continue.
}
private void CheckAllMessages(ContractFailureKind kind, string messageStart, Action <string, Exception, string, ContractFailureKind, Func <string> > fnAssert)
{
foreach (Exception ex in new [] { null, new ArgumentNullException() })
{
fnAssert(messageStart + ".", ex, null, kind, () => {
return(ContractHelper.RaiseContractFailedEvent(kind, null, null, ex));
});
fnAssert(messageStart + ". Message", ex, null, kind, () => {
return(ContractHelper.RaiseContractFailedEvent(kind, "Message", null, ex));
});
fnAssert(messageStart + ": Condition", ex, "Condition", kind, () => {
return(ContractHelper.RaiseContractFailedEvent(kind, null, "Condition", ex));
});
fnAssert(messageStart + ": Condition Message", ex, "Condition", kind, () => {
return(ContractHelper.RaiseContractFailedEvent(kind, "Message", "Condition", ex));
});
}
}
private void AssertException(Action block, ContractFailureKind expectedKind, string expectedMessage, string expectedUserMessage, Exception expectedInnerException)
{
try
{
block();
}
catch (Exception ex)
{
var cex = ex as ContractException;
if (cex == null)
Assert.Fail("Unexpected Exception");
Assert.True(cex.Kind == expectedKind, "Kind");
Assert.True(cex.Message == expectedMessage, "Message");
Assert.True(cex.UserMessage == expectedUserMessage, "UserMessage");
if (cex.InnerException != null)
Assert.True(cex.InnerException.Equals(expectedInnerException), "InnerException");
else if (cex.InnerException == null && expectedInnerException != null)
Assert.Fail("InnerException");
}
}
static partial void TriggerFailureImplementation(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException)
{
// If we're here, our intent is to pop up a dialog box (if we can). For developers
// interacting live with a debugger, this is a good experience. For Silverlight
// hosted in Internet Explorer, the assert window is great. If we cannot
// pop up a dialog box, throw an exception (consider a library compiled with
// "Assert On Failure" but used in a process that can't pop up asserts, like an
// NT Service).
if (!Environment.UserInteractive)
{
throw new ContractException(kind, displayMessage, userMessage, conditionText, innerException);
}
// May need to rethink Assert.Fail w/ TaskDialogIndirect as a model. Window title. Main instruction. Content. Expanded info.
// Optional info like string for collapsed text vs. expanded text.
String windowTitle = SR.GetResourceString(GetResourceNameForFailure(kind));
const int numStackFramesToSkip = 2; // To make stack traces easier to read
System.Diagnostics.Assert.Fail(conditionText, displayMessage, windowTitle, COR_E_CODECONTRACTFAILED, StackTrace.TraceFormat.Normal, numStackFramesToSkip);
// If we got here, the user selected Ignore. Continue.
}
internal static string GetFailureMessage(ContractFailureKind failureKind, string?conditionText)
{
string result;
var withCondition = !string.IsNullOrEmpty(conditionText);
switch (failureKind)
{
case ContractFailureKind.Assert:
result = withCondition ? $"Assertion failed: {conditionText}" : "Assertion failed.";
break;
case ContractFailureKind.Assume:
result = withCondition ? $"Assumption failed: {conditionText}" : "Assumption failed.";
break;
case ContractFailureKind.Precondition:
result = withCondition ? $"Precondition failed: {conditionText}" : "Precondition failed.";
break;
case ContractFailureKind.Postcondition:
result = withCondition ? $"Postcondition failed: {conditionText}" : "Postcondition failed.";
break;
case ContractFailureKind.Invariant:
result = withCondition ? $"Invariant failed: {conditionText}" : "Invariant failed.";
break;
case ContractFailureKind.PostconditionOnException:
result = withCondition ? $"Postcondition failed after throwing an exception: {conditionText}" : "Postcondition failed after throwing an exception.";
break;
default:
result = "Assumption failed.";
Contract.Assume(false, "Unreachable code");
break;
}
return(result);
}
private void CheckAllMessages (ContractFailureKind kind, string messageStart, Action<string, Exception, string, ContractFailureKind, Func<string>> fnAssert)
{
foreach (Exception ex in new [] { null, new ArgumentNullException () }) {
fnAssert (messageStart + ".", ex, null, kind, () => {
return ContractHelper.RaiseContractFailedEvent (kind, null, null, ex);
});
fnAssert (messageStart + ". Message", ex, null, kind, () => {
return ContractHelper.RaiseContractFailedEvent (kind, "Message", null, ex);
});
fnAssert (messageStart + ": Condition", ex, "Condition", kind, () => {
return ContractHelper.RaiseContractFailedEvent (kind, null, "Condition", ex);
});
fnAssert (messageStart + ": Condition Message", ex, "Condition", kind, () => {
return ContractHelper.RaiseContractFailedEvent (kind, "Message", "Condition", ex);
});
}
}
private static string GetDisplayMessage(ContractFailureKind failureKind, string userMessage, string conditionText)
{
string text = ContractHelper.GetResourceNameForFailure(failureKind);
string resourceString;
if (!string.IsNullOrEmpty(conditionText))
{
text += "_Cnd";
resourceString = Environment.GetResourceString(text, new object[]
{
conditionText
});
}
else
{
resourceString = Environment.GetResourceString(text);
}
if (!string.IsNullOrEmpty(userMessage))
{
return(resourceString + " " + userMessage);
}
return(resourceString);
}
private static String GetResourceNameForFailure(ContractFailureKind failureKind)
{
String resourceName = null;
switch (failureKind)
{
case ContractFailureKind.Assert:
resourceName = "AssertionFailed";
break;
case ContractFailureKind.Assume:
resourceName = "AssumptionFailed";
break;
case ContractFailureKind.Precondition:
resourceName = "PreconditionFailed";
break;
case ContractFailureKind.Postcondition:
resourceName = "PostconditionFailed";
break;
case ContractFailureKind.Invariant:
resourceName = "InvariantFailed";
break;
case ContractFailureKind.PostconditionOnException:
resourceName = "PostconditionOnExceptionFailed";
break;
default:
Contract.Assume(false, "Unreachable code");
resourceName = "AssumptionFailed";
break;
}
return(resourceName);
}
public void TestRaiseContractFailedEventHandled()
{
string expectedMsg = null;
Exception originalException = null;
string expectedCondition = null;
ContractFailureKind expectedKind = ContractFailureKind.Assert;
Contract.ContractFailed += (sender, e) => {
Assert.AreEqual(expectedMsg, e.Message, "TestRaiseContractFailedEventHandled() event message wrong");
Assert.AreSame(originalException, e.OriginalException, "TestRaiseContractFailedEventHandled() event exception wrong");
Assert.AreEqual(expectedCondition, e.Condition, "TestRaiseContractFailedEventHandled() event condition wrong");
Assert.AreEqual(expectedKind, e.FailureKind, "TestRaiseContractFailedEventHandled() event failure kind wrong");
e.SetHandled();
};
this.CheckAllKinds((expected, ex, condition, kind, fnTest) => {
expectedMsg = expected;
originalException = ex;
expectedCondition = condition;
expectedKind = kind;
string msg = fnTest();
Assert.IsNull(msg, "TestRaiseContractFailedEventHandled() expected null message");
});
}
public static string RaiseContractFailedEvent(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException)
{
throw new NotImplementedException();
}
private static void TriggerFailureImplementation(ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException)
{
if (Environment.IsCLRHosted)
{
TriggerCodeContractEscalationPolicy(kind, displayMessage, conditionText, innerException);
}
if (!Environment.UserInteractive)
{
Environment.FailFast(displayMessage);
}
Assert.Check(false, conditionText, displayMessage);
}
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;
}
public static string RaiseContractFailedEvent(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException)
{
return(System.Runtime.CompilerServices.ContractHelper.RaiseContractFailedEvent(failureKind, userMessage, conditionText, innerException));
}
public static void TriggerFailure(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException)
{
TriggerFailureImplementation(kind, displayMessage, userMessage, conditionText, innerException);
}
/// <summary>
/// This method is used internally to trigger a failure indicating to the "programmer" that he is using the interface incorrectly.
/// It is NEVER used to indicate failure of actual contracts at runtime.
/// </summary>
static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind)
{
// @TODO: localize this
Internal.ContractHelper.TriggerFailure(kind, "Must use the rewriter when using Contract." + contractKind, null, null, null);
}
internal static void TriggerCodeContractFailure(ContractFailureKind failureKind, String message, String condition, String exceptionAsString)
{
}
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);
}
/// <summary> /// Implements the default failure behavior of the platform. Under the BCL, it triggers an Assert box. /// </summary> static partial void TriggerFailureImplementation(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException);
private static void TriggerCodeContractEscalationPolicy(ContractFailureKind failureKind, string message, string conditionText, Exception innerException)
{
string exceptionAsString = null;
if (innerException != null)
{
exceptionAsString = innerException.ToString();
}
Environment.TriggerCodeContractFailure(failureKind, message, conditionText, exceptionAsString);
}
internal static void TriggerCodeContractFailure(ContractFailureKind failureKind, String message, String condition, String exceptionAsString)
{
}
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)
{
string resultFailureMessage = "Contract failed";
RaiseContractFailedEventImplementation(failureKind, userMessage, conditionText, innerException, ref resultFailureMessage);
return resultFailureMessage;
}
public ContractException(string msg) : base(msg)
{
_Kind = ContractFailureKind.Precondition;
}
public ContractFailedEventArgs(ContractFailureKind failureKind, string message, string condition, Exception originalException)
{
}
/// <summary> /// This method is used internally to trigger a failure indicating to the "programmer" that he is using the interface incorrectly. /// It is NEVER used to indicate failure of actual contracts at runtime. /// </summary> static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind);
private Literal TranslateKindForBackwardCompatibility(ContractFailureKind kind)
{
switch (kind)
{
case ContractFailureKind.Assert:
{
var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Assert"));
Contract.Assume(field != null);
return field.DefaultValue;
}
case ContractFailureKind.Assume:
{
var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Assume"));
Contract.Assume(field != null);
return field.DefaultValue;
}
case ContractFailureKind.Invariant:
{
var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Invariant"));
Contract.Assume(field != null);
return field.DefaultValue;
}
case ContractFailureKind.Postcondition:
{
var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Postcondition"));
Contract.Assume(field != null);
return field.DefaultValue;
}
case ContractFailureKind.PostconditionOnException:
{
var pe = this.contractNodes.ContractFailureKind.GetField(Identifier.For("PostconditionOnException"));
// hack
if (pe == null)
{ // Old CLR 4.0 beta
var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Postcondition"));
Contract.Assume(field != null);
return field.DefaultValue;
}
return pe.DefaultValue;
}
case ContractFailureKind.Precondition:
{
var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Precondition"));
Contract.Assume(field != null);
return field.DefaultValue;
}
default:
{
throw new ApplicationException(String.Format("Unexpected failure kind {0}", kind.ToString()));
}
}
}
public static void TriggerFailure(ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException)
{
throw new NotImplementedException();
}
private static String GetDisplayMessage(ContractFailureKind failureKind, String userMessage, String conditionText)
{
String resourceName = null;
switch (failureKind)
{
case ContractFailureKind.Assert:
resourceName = "AssertionFailed";
break;
case ContractFailureKind.Assume:
resourceName = "AssumptionFailed";
break;
case ContractFailureKind.Precondition:
resourceName = "PreconditionFailed";
break;
case ContractFailureKind.Postcondition:
resourceName = "PostconditionFailed";
break;
case ContractFailureKind.Invariant:
resourceName = "InvariantFailed";
break;
case ContractFailureKind.PostconditionOnException:
resourceName = "PostconditionOnExceptionFailed";
break;
default:
Contract.Assume(false, "Unreachable code");
resourceName = "AssumptionFailed";
break;
}
var failureMessage = myResourceManager.GetString(resourceName);
if (failureMessage == null)
{ // Hack for pre-V4 CLR�s
failureMessage = String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0} failed", failureKind);
}
// Now format based on presence of condition/userProvidedMessage
if (!String.IsNullOrEmpty(conditionText))
{
if (!String.IsNullOrEmpty(userMessage))
{
// both != null
return(String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0}: {1} {2}", failureMessage, conditionText, userMessage));
}
else
{
// condition != null, userProvidedMessage == null
return(String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0}: {1}", failureMessage, conditionText));
}
}
else
{
if (!String.IsNullOrEmpty(userMessage))
{
// condition null, userProvidedMessage != null
return(String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0}: {1}", failureMessage, userMessage));
}
else
{
// both null
return(failureMessage);
}
}
}
internal static string GetFailureMessage(ContractFailureKind failureKind)
{
return(GetFailureMessage(failureKind, ""));
}
public static void TriggerFailure(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException)
{
System.Runtime.CompilerServices.ContractHelper.TriggerFailure(kind, displayMessage, userMessage, conditionText, innerException);
}
public ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException) : base(failure, innerException)
{
this._Kind = kind;
this._UserMessage = userMessage;
this._Condition = condition;
}
public extern ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException);
public static void TriggerFailure (ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException)
{
StringBuilder msg = new StringBuilder (50);
if (conditionText != null) {
msg.Append ("Expression: ");
msg.AppendLine (conditionText);
}
msg.Append ("Description: ");
if (displayMessage != null) {
msg.Append (displayMessage);
}
#if MOONLIGHT
// Silverlight shows a dialog that let you Abort (kill process/browser), Retry or Ignore
// Moonlight will simply warn and ignore (at least until FailFast is implemented)
// using reflection into System.Windows.Browser to popup an browser alert
alert.Invoke (window, new object [] { msg.ToString () });
#else
if (Environment.UserInteractive) {
// FIXME: This should trigger an assertion.
// But code will never get here at the moment, as Environment.UserInteractive currently
// always returns false.
throw new ContractShouldAssertException (msg.ToString ());
} else {
// Note that FailFast() currently throws a NotImplementedException()
Environment.FailFast(msg.ToString()/*, new ExecutionEngineException()*/);
}
#endif
}
/// <summary> /// Rewriter will call this method on a contract failure to allow listeners to be notified. /// The method should not perform any failure (assert/throw) itself. /// This method has 3 functions: /// 1. Call any contract hooks (such as listeners to Contract failed events) /// 2. Determine if the listeneres deem the failure as handled (then resultFailureMessage should be set to null) /// 3. Produce a localized resultFailureMessage used in advertising the failure subsequently. /// </summary> /// <param name="resultFailureMessage">Should really be out (or the return value), but partial methods are not flexible enough. /// On exit: null if the event was handled and should not trigger a failure. /// Otherwise, returns the localized failure message</param> static partial void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException, ref string resultFailureMessage);
public static void TriggerFailure(ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException)
{
TriggerFailureImplementation(kind, displayMessage, userMessage, conditionText, innerException);
}
/// <summary> /// Without contract rewriting, failing Assert/Assumes end up calling this method. /// Code going through the contract rewriter never calls this method. Instead, the rewriter produced failures call /// System.Runtime.CompilerServices.ContractHelper.RaiseContractFailedEvent, followed by /// System.Runtime.CompilerServices.ContractHelper.TriggerFailure. /// </summary> static partial void ReportFailure(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException);
public static void TriggerFailure(ContractFailureKind kind, string msg, string userMessage, string conditionTxt)
{
throw new ContractException(kind, msg, userMessage, conditionTxt);
}
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), "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;
}
}
resultFailureMessage = returnValue;
}
private ContractException(SerializationInfo info, StreamingContext context) : base(info, context)
{
this._Kind = (ContractFailureKind) info.GetInt32("Kind");
this._UserMessage = info.GetString("UserMessage");
this._Condition = info.GetString("Condition");
}
private static string GetFailureMessage(ContractFailureKind failureKind, string conditionText, Provenance provenence)
{
return(string.IsNullOrEmpty(conditionText)
? string.Format(CultureInfo.InvariantCulture, "{0}", failureKind.ToDisplayString())
: string.Format(CultureInfo.InvariantCulture, "{0}: {1}", failureKind.ToDisplayString(), conditionText));
}
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;
}
