protected static async Task ScheduleCommandAgainstEventSourcedAggregate(
string targetId,
string etag,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null)
{
var aggregateId = Guid.Parse(targetId);
var repository = Configuration.Current.Repository <Order>();
if (await repository.GetLatest(aggregateId) == null)
{
await repository.Save(new Order(new CreateOrder(Any.FullName())
{
AggregateId = aggregateId
}));
}
var command = new AddItem
{
ETag = etag,
ProductName = Any.Word(),
Price = 10m
};
var scheduledCommand = new ScheduledCommand <Order>(
command,
aggregateId,
dueTime,
deliveryDependsOn);
var scheduler = Configuration.Current.CommandScheduler <Order>();
await scheduler.Schedule(scheduledCommand);
}
private void FromIfThrowToRequires(IPrecondition assertion, bool isGeneric)
{
// Convertion from if-throw precondition to Contract.Requires
// contains following steps:
// 1. Negate condition from the if statement (because if (s == null) throw ANE means that Contract.Requires(s != null))
// 2. Create Contract.Requires expression (with all optional generic argument and optional message
// 3. Add required using statements if necessary (for Contract class and Exception type)
// 4. Replace if-throw statement with newly created contract statement
var ifThrowAssertion = (IfThrowPrecondition)assertion;
ICSharpExpression negatedExpression =
CSharpExpressionUtil.CreateLogicallyNegatedExpression(ifThrowAssertion.IfStatement.Condition);
Contract.Assert(negatedExpression != null);
string predicateCheck = negatedExpression.GetText();
ICSharpStatement newStatement = null;
if (isGeneric)
{
newStatement = CreateGenericContractRequires(ifThrowAssertion.ExceptionTypeName, predicateCheck,
ifThrowAssertion.Message);
}
else
{
newStatement = CreateNonGenericContractRequires(predicateCheck, ifThrowAssertion.Message);
}
ReplaceStatements(ifThrowAssertion.CSharpStatement, newStatement);
}
public ConvertToContractRequiresFix(ValidationResult currentStatement, ValidatedContractBlock validatedContractBlock)
: base(currentStatement, validatedContractBlock)
{
// TODO: refactoring required!! Not clear logic
_precondition =
ContractsEx.Assertions.ContractStatementFactory.TryCreatePrecondition(currentStatement.Statement);
}
public ConvertToContractRequiresFix(ValidationResult currentStatement, ValidatedContractBlock validatedContractBlock)
: base(currentStatement, validatedContractBlock)
{
// TODO: refactoring required!! Not clear logic
_precondition =
ContractsEx.Assertions.ContractStatementFactory.TryCreatePrecondition(currentStatement.Statement);
}
protected abstract IScheduledCommand <T> CreateScheduledCommand <T>(
ICommand <T> command,
Guid aggregateId,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null,
IClock clock = null)
where T : class, IEventSourced;
/// <summary>
/// Creates a new package for an IPrecondition contract.
/// </summary>
public XPrecondition(IMetadataHost host, IPrecondition precondition, string inheritedFrom, string inheritedFromTypeName, DocTracker docTracker)
: base(host, inheritedFrom, inheritedFromTypeName, docTracker)
{
Contract.Requires(precondition != null);
Contract.Requires(docTracker != null);
this.precondition = precondition;
this.exception = GetExceptionId(precondition);
}
protected override Task Schedule(
string targetId,
string etag,
DateTimeOffset? dueTime = null,
IPrecondition deliveryDependsOn = null) =>
ScheduleCommandAgainstEventSourcedAggregate(targetId,
etag,
dueTime,
deliveryDependsOn);
public void Visit(IPrecondition precondition)
{
Contract.Assert(precondition != null);
Visit((IContractElement)precondition);
if (precondition.ExceptionToThrow != null)
{
Visit(precondition.ExceptionToThrow);
}
}
protected override Task Schedule(
string targetId,
string etag,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null) =>
ScheduleCommandAgainstNonEventSourcedAggregate(targetId,
etag,
dueTime,
deliveryDependsOn);
/// <summary>
/// Traverses the pre condition.
/// </summary>
public void Traverse(IPrecondition precondition)
{
Contract.Requires(precondition != null);
preorderVisitor.Visit(precondition);
if (StopTraversal)
{
return;
}
TraverseChildren(precondition);
}
public ScheduledCommand(
ICommand <TTarget> command,
Guid aggregateId,
DateTimeOffset?dueTime = null,
IPrecondition deliveryPrecondition = null) :
this(command,
aggregateId.ToString(),
dueTime,
deliveryPrecondition)
{
}
public ITransitionBuilder <TState, TInput> WithPrecondition(
ConnectorKey connectorKey,
System.Action <IPreconditionBuilder> guard = null)
{
var preconditionBuilder = new PreconditionBuilder(connectorKey);
guard?.Invoke(preconditionBuilder);
Procondition = preconditionBuilder;
return(this);
}
/// <summary>
/// Traverses the children of the pre condition.
/// </summary>
public virtual void TraverseChildren(IPrecondition precondition)
{
Contract.Requires(precondition != null);
TraverseChildren((IContractElement)precondition);
if (StopTraversal)
{
return;
}
if (precondition.ExceptionToThrow != null)
{
Traverse(precondition.ExceptionToThrow);
}
}
private void FromRequiresToGenericRequires(IPrecondition assertion)
{
var requiresAssertion = (ContractRequires)assertion;
Contract.Assert(!requiresAssertion.IsGenericRequires);
var exceptionType = requiresAssertion.PotentialGenericVersionException();
string predicate = requiresAssertion.OriginalPredicateExpression.GetText();
var newStatement = CreateGenericContractRequires(exceptionType, predicate, requiresAssertion.Message);
ReplaceStatements(requiresAssertion.CSharpStatement, newStatement);
}
private void FromGenericRequiresToRequires(IPrecondition assertion)
{
var requiresAssertion = (ContractRequires)assertion;
Contract.Assert(requiresAssertion.IsGenericRequires);
string predicateCheck = requiresAssertion.OriginalPredicateExpression.GetText();
var newStatement = CreateNonGenericContractRequires(predicateCheck, requiresAssertion.Message);
ReplaceStatements(requiresAssertion.CSharpStatement, newStatement);
RemoveSystemNamespaceUsingIfPossible();
}
public static Task <IScheduledCommand <TTarget> > Schedule <TTarget>(
ConstructorCommand <TTarget> command,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null,
IClock clock = null)
where TTarget : class =>
Configuration
.Current
.CommandScheduler <TTarget>()
.Schedule(
command,
dueTime,
deliveryDependsOn,
clock);
private ScheduledCommand(
ICommand <TTarget> command,
string targetId = null,
Guid?aggregateId = null,
DateTimeOffset?dueTime = null,
IPrecondition deliveryPrecondition = null) :
this(command,
targetId
.IfNotNull()
.Else(() => aggregateId?.ToString()),
dueTime,
deliveryPrecondition)
{
}
protected override IScheduledCommand <T> CreateScheduledCommand <T>(
ICommand <T> command,
Guid aggregateId,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null,
IClock clock = null)
{
return(new ScheduledCommand <T>(command,
aggregateId,
dueTime,
deliveryDependsOn)
{
Clock = clock
});
}
/// <summary>
/// Schedules a constructor command on the specified scheduler.
/// </summary>
public static async Task <IScheduledCommand <TTarget> > Schedule <TTarget>(
this ICommandScheduler <TTarget> scheduler,
ConstructorCommand <TTarget> command,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null,
IClock clock = null)
where TTarget : class
{
return(await scheduler.Schedule(
command : command,
targetId : command.AggregateId.ToString(),
dueTime : dueTime,
deliveryDependsOn : deliveryDependsOn,
clock : clock));
}
public PreconditionConverterExecutor(ICSharpStatement preconditionStatement, IPrecondition precondition,
PreconditionType sourcePreconditionType,
PreconditionType destinationPreconditionType)
: base(preconditionStatement)
{
Contract.Requires(precondition != null);
Contract.Requires(sourcePreconditionType != destinationPreconditionType);
_precondition = precondition;
_sourcePreconditionType = sourcePreconditionType;
_destinationPreconditionType = destinationPreconditionType;
InitializeConverters();
}
public PreconditionConverterExecutor(ICSharpStatement preconditionStatement, IPrecondition precondition,
PreconditionType sourcePreconditionType,
PreconditionType destinationPreconditionType)
: base(preconditionStatement)
{
Contract.Requires(precondition != null);
Contract.Requires(sourcePreconditionType != destinationPreconditionType);
_precondition = precondition;
_sourcePreconditionType = sourcePreconditionType;
_destinationPreconditionType = destinationPreconditionType;
InitializeConverters();
}
protected override IScheduledCommand <T> CreateScheduledCommand <T>(
ICommand <T> command,
Guid aggregateId,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null,
IClock clock = null)
{
return(new CommandScheduled <T>
{
Command = command,
AggregateId = aggregateId,
DueTime = dueTime,
DeliveryPrecondition = deliveryDependsOn,
Clock = clock
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ScheduledCommand{TTarget}"/> class.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="targetId">The target identifier.</param>
/// <param name="dueTime">The due time.</param>
/// <param name="deliveryPrecondition">The delivery precondition.</param>
/// <param name="clock">The clock.</param>
/// <exception cref="System.ArgumentNullException"></exception>
/// <exception cref="System.ArgumentException">Parameter targetId cannot be null, empty or whitespace.</exception>
public ScheduledCommand(
ICommand <TTarget> command,
string targetId,
DateTimeOffset?dueTime = null,
IPrecondition deliveryPrecondition = null,
IClock clock = null)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (string.IsNullOrWhiteSpace(targetId))
{
throw new ArgumentException("Parameter targetId cannot be null, empty or whitespace.");
}
var constructorCommand = command as ConstructorCommand <TTarget>;
if (constructorCommand != null)
{
if (typeof(IEventSourced).IsAssignableFrom(typeof(TTarget)))
{
if (constructorCommand.AggregateId != Guid.Parse(targetId))
{
throw new ArgumentException($"ConstructorCommand.AggregateId ({constructorCommand.AggregateId}) does not match ScheduledCommand.AggregateId ({targetId})");
}
}
else
{
if (constructorCommand.TargetId != targetId)
{
throw new ArgumentException($"ConstructorCommand.TargetId ({constructorCommand.TargetId}) does not match ScheduledCommand.TargetId ({targetId})");
}
}
}
Command = command;
TargetId = targetId;
DueTime = dueTime;
DeliveryPrecondition = deliveryPrecondition;
Clock = clock;
this.EnsureCommandHasETag();
}
/// <summary>
/// Schedules a command on the specified scheduler.
/// </summary>
public static async Task <IScheduledCommand <TTarget> > Schedule <TCommand, TTarget>(
this ICommandScheduler <TTarget> scheduler,
string targetId,
TCommand command,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null)
where TCommand : ICommand <TTarget>
{
var scheduledCommand = new ScheduledCommand <TTarget>(
command,
targetId,
dueTime,
deliveryDependsOn);
await scheduler.Schedule(scheduledCommand);
return(scheduledCommand);
}
public IStateBuilder <TState, TInput> WithPrecondition(ConnectorKey connectorKey, System.Action <IPreconditionBuilder> precondition = null)
{
if (connectorKey == null)
{
throw new ArgumentNullException(nameof(connectorKey));
}
if (string.IsNullOrWhiteSpace(connectorKey.Identifier))
{
throw new ArgumentException("ConnectorKey must have a valid value", nameof(connectorKey));
}
var preconditionBuilder = new PreconditionBuilder(connectorKey);
precondition?.Invoke(preconditionBuilder);
Precondition = preconditionBuilder;
return(this);
}
public Queue()
{
foreach (Type t in Resolver.Instance.GenericPreconditionToString.Keys)
{
ConstructorInfo ctor = t.GetConstructor(new Type[0]);
if (ctor == null)
{
continue;
}
IPrecondition prec = (IPrecondition)ctor.Invoke(new object[0]);
if (prec == null)
{
continue;
}
_genericPreconditions.Add(prec, new PreConditionState {
Name = Resolver.Instance.GenericPreconditionToString[t], CanExecute = true, CheckTime = DateTime.Now
});
}
}
private static string GetExceptionId(IPrecondition precondition)
{
Contract.Requires(precondition != null);
if (precondition.ExceptionToThrow != null)
{
ITypeOf asTypeOf = precondition.ExceptionToThrow as ITypeOf;
ITypeReference unspecializedExceptionType;
if (asTypeOf != null)
{
unspecializedExceptionType = MethodHelper.Unspecialize(asTypeOf.TypeToGet);
}
else//Legacy contracts package exceptions differently then regular contracts.
{
unspecializedExceptionType = MethodHelper.Unspecialize(precondition.ExceptionToThrow.Type);
}
return(TypeHelper.GetTypeName(unspecializedExceptionType, NameFormattingOptions.DocumentationId));
}
return(null);
}
public ScheduledCommand(
ICommand <TTarget> command,
string targetId,
DateTimeOffset?dueTime = null,
IPrecondition deliveryPrecondition = null)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (string.IsNullOrWhiteSpace(targetId))
{
throw new ArgumentException("Parameter targetId cannot be null, empty or whitespace.");
}
Command = command;
TargetId = targetId;
DueTime = dueTime;
DeliveryPrecondition = deliveryPrecondition;
this.EnsureCommandHasETag();
}
protected async Task ScheduleCommandAgainstNonEventSourcedAggregate(
string targetId,
string etag,
DateTimeOffset?dueTime = null,
IPrecondition deliveryDependsOn = null)
{
var repository = Configuration.Current.Store <CommandTarget>();
if (await repository.Get(targetId) == null)
{
await repository.Put(new CommandTarget(targetId));
}
var command = new ScheduledCommand <CommandTarget>(
new TestCommand(etag),
targetId,
dueTime,
deliveryDependsOn);
var scheduler = Configuration.Current.CommandScheduler <CommandTarget>();
await scheduler.Schedule(command);
}
/// <summary>
/// Visits the given precondition.
/// </summary>
public virtual void Visit(IPrecondition precondition)
{
this.Visit((IContractElement)precondition);
}
public void Visit(IPrecondition precondition)
{
this.traverser.Traverse(precondition);
}
/// <summary>
/// Creates a new package for an IPrecondition contract.
/// </summary>
public XPrecondition(IMetadataHost host, IPrecondition precondition, string inheritedFrom, string inheritedFromTypeName, DocTracker docTracker)
: base(host, inheritedFrom, inheritedFromTypeName, docTracker) {
Contract.Requires(precondition != null);
Contract.Requires(docTracker != null);
this.precondition = precondition;
this.exception = GetExceptionId(precondition);
}
/// <summary>
/// Rewrites the given pre condition.
/// </summary>
public virtual IPrecondition Rewrite(IPrecondition precondition)
{
var mutablePrecondition = precondition as Precondition;
if (mutablePrecondition == null) return precondition;
this.RewriteChildren(mutablePrecondition);
return mutablePrecondition;
}
private void FromGenericRequiresToRequires(IPrecondition assertion)
{
var requiresAssertion = (ContractRequires)assertion;
Contract.Assert(requiresAssertion.IsGenericRequires);
string predicateCheck = requiresAssertion.OriginalPredicateExpression.GetText();
var newStatement = CreateNonGenericContractRequires(predicateCheck, requiresAssertion.Message);
ReplaceStatements(requiresAssertion.CSharpStatement, newStatement);
RemoveSystemNamespaceUsingIfPossible();
}
/// <summary>
/// Makes a shallow copy of the given precondition.
/// </summary>
public virtual Precondition Copy(IPrecondition precondition) {
Contract.Requires(precondition != null);
Contract.Ensures(Contract.Result<Precondition>() != null);
return new Precondition(precondition);
}
/// <summary>
/// Makes a deep copy of the given precondition.
/// </summary>
public Precondition Copy(IPrecondition precondition) {
Contract.Requires(precondition != null);
Contract.Ensures(Contract.Result<Precondition>() != null);
var mutableCopy = this.shallowCopier.Copy(precondition);
this.Copy((ContractElement)mutableCopy);
if (mutableCopy.ExceptionToThrow != null)
mutableCopy.ExceptionToThrow = this.Copy(mutableCopy.ExceptionToThrow);
return mutableCopy;
}
/// <summary>
/// Creates a precondition that shares all of the information in <paramref name="precondition"/>.
/// </summary>
/// <param name="precondition"></param>
public Precondition(IPrecondition precondition)
: base(precondition) {
this.alwaysCheckedAtRuntime = precondition.AlwaysCheckedAtRuntime;
this.exceptionToThrow = precondition.ExceptionToThrow;
}
public PreconditionNot(IPrecondition precondition)
{
mPrecondition = precondition;
}
public void Visit(IPrecondition precondition)
{
this.result = this.copier.Copy(precondition);
}
/// <summary>
/// Makes a shallow copy of the given precondition.
/// </summary>
public virtual Precondition Copy(IPrecondition precondition)
{
return new Precondition(precondition);
}
/// <summary>
/// Visits the specified precondition.
/// </summary>
/// <param name="precondition">The precondition.</param>
public virtual IPrecondition Visit(IPrecondition precondition)
{
Precondition mutablePrecondition = precondition as Precondition;
if (!this.copyOnlyIfNotAlreadyMutable || mutablePrecondition == null)
mutablePrecondition = new Precondition(precondition);
return this.Visit(mutablePrecondition);
}
public void Visit(IPrecondition precondition)
{
Contract.Requires(precondition != null);
throw new NotImplementedException();
}
public PreconditionAnd(IPrecondition leftPrecondition, IPrecondition rightPrecondition)
{
mLeftPrecondition = leftPrecondition;
mRightPrecondition = rightPrecondition;
}
public static Precondition Clone(this IPrecondition precondition) =>
new Precondition
{
ConnectorKey = precondition.ConnectorKey,
Configuration = new Dictionary <string, string>((IDictionary <string, string>)precondition.Settings)
};
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the given pre condition.
/// </summary>
public virtual void Visit(IPrecondition precondition)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(precondition);
this.Visit(precondition.Condition);
if (precondition.Description != null)
this.Visit(precondition.Description);
if (precondition.ExceptionToThrow != null)
this.Visit(precondition.ExceptionToThrow);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
public PreconditionNotMetException(IPrecondition precondition)
: base("Precondition was not met: " + precondition)
{
}
/// <summary>
/// Visits the given precondition.
/// </summary>
public virtual void Visit(IPrecondition precondition)
{
}
private void FromRequiresToGenericRequires(IPrecondition assertion)
{
var requiresAssertion = (ContractRequires) assertion;
Contract.Assert(!requiresAssertion.IsGenericRequires);
var exceptionType = requiresAssertion.PotentialGenericVersionException();
string predicate = requiresAssertion.OriginalPredicateExpression.GetText();
var newStatement = CreateGenericContractRequires(exceptionType, predicate, requiresAssertion.Message);
ReplaceStatements(requiresAssertion.CSharpStatement, newStatement);
}
/// <summary>
/// Traverses the pre condition.
/// </summary>
public void Traverse(IPrecondition precondition)
{
Contract.Requires(precondition != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(precondition);
if (this.StopTraversal) return;
this.TraverseChildren(precondition);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(precondition);
}
private void FromIfThrowToRequires(IPrecondition assertion, bool isGeneric)
{
// Convertion from if-throw precondition to Contract.Requires
// contains following steps:
// 1. Negate condition from the if statement (because if (s == null) throw ANE means that Contract.Requires(s != null))
// 2. Create Contract.Requires expression (with all optional generic argument and optional message
// 3. Add required using statements if necessary (for Contract class and Exception type)
// 4. Replace if-throw statement with newly created contract statement
var ifThrowAssertion = (IfThrowPrecondition) assertion;
ICSharpExpression negatedExpression =
CSharpExpressionUtil.CreateLogicallyNegatedExpression(ifThrowAssertion.IfStatement.Condition);
Contract.Assert(negatedExpression != null);
string predicateCheck = negatedExpression.GetText();
ICSharpStatement newStatement = null;
if (isGeneric)
{
newStatement = CreateGenericContractRequires(ifThrowAssertion.ExceptionTypeName, predicateCheck,
ifThrowAssertion.Message);
}
else
{
newStatement = CreateNonGenericContractRequires(predicateCheck, ifThrowAssertion.Message);
}
ReplaceStatements(ifThrowAssertion.CSharpStatement, newStatement);
}
/// <summary>
/// Traverses the children of the pre condition.
/// </summary>
public virtual void TraverseChildren(IPrecondition precondition)
{
Contract.Requires(precondition != null);
this.TraverseChildren((IContractElement)precondition);
if (this.StopTraversal) return;
if (precondition.ExceptionToThrow != null)
this.Traverse(precondition.ExceptionToThrow);
}
/// <summary>
/// 设置节点的前提条件（外在前提）
/// </summary>
/// <param 前提条件="precondition"></param>
public NodeBase SetPrecondition(IPrecondition precondition)
{
mPrecondition = precondition;
return(this);
}
protected async Task ScheduleCommandAgainstNonEventSourcedAggregate(
string targetId,
string etag,
DateTimeOffset? dueTime = null,
IPrecondition deliveryDependsOn = null)
{
var repository = Configuration.Current.Store<CommandTarget>();
if (await repository.Get(targetId) == null)
{
await repository.Put(new CommandTarget(targetId));
}
var command = new ScheduledCommand<CommandTarget>(
new TestCommand(etag),
targetId,
dueTime,
deliveryDependsOn);
var scheduler = Configuration.Current.CommandScheduler<CommandTarget>();
await scheduler.Schedule(command);
}
protected static async Task ScheduleCommandAgainstEventSourcedAggregate(
string targetId,
string etag,
DateTimeOffset? dueTime = null,
IPrecondition deliveryDependsOn = null)
{
var aggregateId = Guid.Parse(targetId);
var repository = Configuration.Current.Repository<Order>();
if (await repository.GetLatest(aggregateId) == null)
{
await repository.Save(new Order(new CreateOrder(Any.FullName())
{
AggregateId = aggregateId
}));
}
var command = new AddItem
{
ETag = etag,
ProductName = Any.Word(),
Price = 10m
};
var scheduledCommand = new ScheduledCommand<Order>(
command,
aggregateId,
dueTime,
deliveryDependsOn);
var scheduler = Configuration.Current.CommandScheduler<Order>();
await scheduler.Schedule(scheduledCommand);
}
/// <summary>
/// Get the mutable copy of a precondition.
/// </summary>
/// <param name="precondition"></param>
/// <returns></returns>
public virtual Precondition GetMutableCopy(IPrecondition precondition)
{
object cachedValue;
if (this.cache.TryGetValue(precondition, out cachedValue))
return (Precondition)cachedValue;
var result = new Precondition(precondition);
// Probably not necessary, no two postconditions are shared.
this.cache.Add(precondition, result);
this.cache.Add(result, result);
return result;
}
/// <summary>
/// Returns a deep copy of the <param name="precondition"/>.
/// </summary>
public virtual IPrecondition Substitute(IPrecondition precondition)
{
this.coneAlreadyFixed = true;
return this.DeepCopy(new Precondition(precondition));
}
/// <summary>
/// Makes a deep copy of the given precondition.
/// </summary>
public Precondition Copy(IPrecondition precondition)
{
var mutableCopy = this.shallowCopier.Copy(precondition);
this.Copy((ContractElement)mutableCopy);
if (mutableCopy.ExceptionToThrow != null)
mutableCopy.ExceptionToThrow = this.Copy(mutableCopy.ExceptionToThrow);
return mutableCopy;
}
private static string GetExceptionId(IPrecondition precondition) {
Contract.Requires(precondition != null);
if (precondition.ExceptionToThrow != null) {
ITypeOf asTypeOf = precondition.ExceptionToThrow as ITypeOf;
ITypeReference unspecializedExceptionType;
if (asTypeOf != null)
unspecializedExceptionType = MethodHelper.Unspecialize(asTypeOf.TypeToGet);
else//Legacy contracts package exceptions differently then regular contracts.
unspecializedExceptionType = MethodHelper.Unspecialize(precondition.ExceptionToThrow.Type);
return TypeHelper.GetTypeName(unspecializedExceptionType, NameFormattingOptions.DocumentationId);
}
return null;
}
/// <summary>
/// Visits the specified precondition.
/// </summary>
/// <param name="precondition">The precondition.</param>
public virtual IPrecondition Visit(IPrecondition precondition)
{
if (this.stopTraversal) return precondition;
Precondition mutablePrecondition = precondition as Precondition;
if (mutablePrecondition == null) return precondition;
mutablePrecondition.Condition = this.Visit(mutablePrecondition.Condition);
if (mutablePrecondition.Description != null)
mutablePrecondition.Description = this.Visit(mutablePrecondition.Description);
if (mutablePrecondition.ExceptionToThrow != null)
mutablePrecondition.ExceptionToThrow = this.Visit(mutablePrecondition.ExceptionToThrow);
return mutablePrecondition;
}
