Class SynchronizationRule<TLeft, TRight>

Namespace

NMF.Synchronizations

Assembly

NMF.Synchronizations.dll

Denotes an abstract synchronization rule

public abstract class SynchronizationRule<TLeft, TRight> : SynchronizationRuleBase

Type Parameters

TLeft

The LHS type of the synchronization rule

TRight

The RHS type of the synchronization rule

Inheritance

object

SynchronizationRuleBase

SynchronizationRule<TLeft, TRight>

Derived

ModelCopyRule<T>

ModelSynchronizationRule<TLeft, TRight>

Inherited Members

SynchronizationRuleBase.DeclareSynchronization()

SynchronizationRuleBase.Synchronization

SynchronizationRuleBase.SyncRule<TRule>()

SynchronizationRuleBase.Rule<TRule>()

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Constructors

SynchronizationRule()

Creates a new instance

protected SynchronizationRule()

Properties

LeftToRight

Gets the transformation rule responsible of transforming elements from left to right

public TransformationRuleBase<TLeft, TRight> LeftToRight { get; }

Property Value

TransformationRuleBase<TLeft, TRight>

LeftType

Gets the LHS type of this rule

public override sealed Type LeftType { get; }

Property Value

Type

OutputDelayLevel

Gets or sets the output delay level of the transformations

public byte OutputDelayLevel { get; set; }

Property Value

byte

RightToLeft

Gets the transformation rule responsible of transforming elements from right to left

public TransformationRuleBase<TRight, TLeft> RightToLeft { get; }

Property Value

TransformationRuleBase<TRight, TLeft>

RightType

Gets the RHS type of this rule

public override sealed Type RightType { get; }

Property Value

Type

SynchronizationJobs

Gets the jobs performed by this synchronization rule

public ICollection<ISynchronizationJob<TLeft, TRight>> SynchronizationJobs { get; }

Property Value

ICollection<ISynchronizationJob<TLeft, TRight>>

TransformationDelayLevel

Gets or sets the transformation delay level

public byte TransformationDelayLevel { get; set; }

Property Value

byte

Methods

CreateLeftOutput(TRight, IEnumerable<TLeft>, ISynchronizationContext, out bool)

Creates the LHS output

protected virtual TLeft CreateLeftOutput(TRight input, IEnumerable<TLeft> candidates, ISynchronizationContext context, out bool existing)

Parameters

input TRight

The corresponding RHS element

candidates IEnumerable<TLeft>

Candidates for the LHS element or null

context ISynchronizationContext

The synchronization context

existing bool

True, if an existing element is returned, otherwise False

Returns

TLeft

The LHS element

CreateRightOutput(TLeft, IEnumerable<TRight>, ISynchronizationContext, out bool)

Creates the RHS output

protected virtual TRight CreateRightOutput(TLeft input, IEnumerable<TRight> candidates, ISynchronizationContext context, out bool existing)

Parameters

input TLeft

The corresponding LHS element

candidates IEnumerable<TRight>

Candidates for the RHS element or null

context ISynchronizationContext

The synchronization context

existing bool

True, if an existing element is returned, otherwise False

Returns

TRight

The RHS element

MarkInstantiatingFor(SynchronizationRuleBase, Expression<Func<TLeft, bool>>, Expression<Func<TRight, bool>>)

Marks this synchronization rule instantiating for the given other synchronization rule

public void MarkInstantiatingFor(SynchronizationRuleBase synchronizationRule, Expression<Func<TLeft, bool>> leftPredicate = null, Expression<Func<TRight, bool>> rightPredicate = null)

Parameters

synchronizationRule SynchronizationRuleBase

The other synchronization rule with more abstract LHS and RHS types

leftPredicate Expression<Func<TLeft, bool>>

A filter function on the LHS when this instantiation applies or null

rightPredicate Expression<Func<TRight, bool>>

A filter function on the RHS when this instantiation applies or null

ShouldCorrespond(TLeft, TRight, ISynchronizationContext)

Determines whether a correspondence shoulf be established between the given LHS and RHS elements

public virtual bool ShouldCorrespond(TLeft left, TRight right, ISynchronizationContext context)

Parameters

left TLeft

The LHS element

right TRight

The RHS element

context ISynchronizationContext

The context in which the synchronization is run

Returns

bool

True, if the elements should be regarded as corresponding to each other, otherwise false

SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Action<TRight, ITransformationContext, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Action<TRight, ITransformationContext, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightSetter Action<TRight, ITransformationContext, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Func<TRight, ITransformationContext, TValue>, Action<TRight, ITransformationContext, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Func<TRight, ITransformationContext, TValue> rightGetter, Action<TRight, ITransformationContext, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightGetter Func<TRight, ITransformationContext, TValue>

A RHS getter

rightSetter Action<TRight, ITransformationContext, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Action<TRight, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Action<TRight, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSetter Action<TRight, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Func<TRight, TValue>, Action<TRight, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Func<TRight, TValue> rightGetter, Action<TRight, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightGetter Func<TRight, TValue>

A RHS getter

rightSetter Action<TRight, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLateLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateRightToLeftOnly<TValue>(Action<TLeft, ITransformationContext, TValue>, Expression<Func<TRight, ITransformationContext, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeLateRightToLeftOnly<TValue>(Action<TLeft, ITransformationContext, TValue> leftSetter, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector)

Parameters

leftSetter Action<TLeft, ITransformationContext, TValue>

A LHS setter

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateRightToLeftOnly<TValue>(Action<TLeft, TValue>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeLateRightToLeftOnly<TValue>(Action<TLeft, TValue> leftSetter, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSetter Action<TLeft, TValue>

A LHS setter

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateRightToLeftOnly<TValue>(Func<TLeft, ITransformationContext, TValue>, Action<TLeft, ITransformationContext, TValue>, Expression<Func<TRight, ITransformationContext, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeLateRightToLeftOnly<TValue>(Func<TLeft, ITransformationContext, TValue> leftGetter, Action<TLeft, ITransformationContext, TValue> leftSetter, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector)

Parameters

leftGetter Func<TLeft, ITransformationContext, TValue>

A LHS getter

leftSetter Action<TLeft, ITransformationContext, TValue>

A LHS setter

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateRightToLeftOnly<TValue>(Func<TLeft, TValue>, Action<TLeft, TValue>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeLateRightToLeftOnly<TValue>(Func<TLeft, TValue> leftGetter, Action<TLeft, TValue> leftSetter, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftGetter Func<TLeft, TValue>

A LHS getter

leftSetter Action<TLeft, TValue>

A LHS setter

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateRightToLeftOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Expression<Func<TRight, ITransformationContext, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeLateRightToLeftOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLateRightToLeftOnly<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeLateRightToLeftOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLate<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values late

public IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue> SynchronizeLate<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Action<TRight, ITransformationContext, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Action<TRight, ITransformationContext, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightSetter Action<TRight, ITransformationContext, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Action<TRight, ITransformationContext, TValue>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Action<TRight, ITransformationContext, TValue> rightSetter, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightSetter Action<TRight, ITransformationContext, TValue>

A RHS setter

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Func<TRight, ITransformationContext, TValue>, Action<TRight, ITransformationContext, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Func<TRight, ITransformationContext, TValue> rightGetter, Action<TRight, ITransformationContext, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightGetter Func<TRight, ITransformationContext, TValue>

A RHS getter

rightSetter Action<TRight, ITransformationContext, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Func<TRight, ITransformationContext, TValue>, Action<TRight, ITransformationContext, TValue>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Func<TRight, ITransformationContext, TValue> rightGetter, Action<TRight, ITransformationContext, TValue> rightSetter, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightGetter Func<TRight, ITransformationContext, TValue>

A RHS getter

rightSetter Action<TRight, ITransformationContext, TValue>

A RHS setter

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Expression<Func<TRight, ITransformationContext, TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Expression<Func<TRight, ITransformationContext, TValue>>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Action<TRight, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Action<TRight, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSetter Action<TRight, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Action<TRight, TValue>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Action<TRight, TValue> rightSetter, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSetter Action<TRight, TValue>

A RHS setter

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Func<TRight, TValue>, Action<TRight, TValue>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Func<TRight, TValue> rightGetter, Action<TRight, TValue> rightSetter)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightGetter Func<TRight, TValue>

A RHS getter

rightSetter Action<TRight, TValue>

A RHS setter

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Func<TRight, TValue>, Action<TRight, TValue>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Func<TRight, TValue> rightGetter, Action<TRight, TValue> rightSetter, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightGetter Func<TRight, TValue>

A RHS getter

rightSetter Action<TRight, TValue>

A RHS setter

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeLeftToRightOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, TDepLeft>>, Expression<Func<TRight, ITransformationContext, TDepRight>>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent elements using the provided synchronization rule but only Left to Right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight> SynchronizeLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, TDepLeft>> leftSelector, Expression<Func<TRight, ITransformationContext, TDepRight>> rightSelector, Expression<Func<TLeft, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TDepRight>>

The RHS in-model lens

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, TDepLeft>>, Expression<Func<TRight, TDepRight>>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent elements using the provided synchronization rule but only Left to Right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight> SynchronizeLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, TDepLeft>> leftSelector, Expression<Func<TRight, TDepRight>> rightSelector, Expression<Func<TLeft, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TDepRight>>

The RHS in-model lens

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeManyLate<TValue>(Func<TLeft, ICollectionExpression<TValue>>, Func<TRight, ICollectionExpression<TValue>>)

Synchronizes the dependent values

public IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue> SynchronizeManyLate<TValue>(Func<TLeft, ICollectionExpression<TValue>> leftSelector, Func<TRight, ICollectionExpression<TValue>> rightSelector)

Parameters

leftSelector Func<TLeft, ICollectionExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollectionExpression<TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLate<TValue>(Func<TLeft, ICollectionExpression<TValue>>, Func<TRight, ICollectionExpression<TValue>>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent values

public IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue> SynchronizeManyLate<TValue>(Func<TLeft, ICollectionExpression<TValue>> leftSelector, Func<TRight, ICollectionExpression<TValue>> rightSelector, Expression<Func<TLeft, TRight, bool>> guard)

Parameters

leftSelector Func<TLeft, ICollectionExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollectionExpression<TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLeftToRightOnlyLate<TValue>(Func<TLeft, IEnumerableExpression<TValue>>, Func<TRight, ICollection<TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeManyLeftToRightOnlyLate<TValue>(Func<TLeft, IEnumerableExpression<TValue>> leftSelector, Func<TRight, ICollection<TValue>> rightSelector)

Parameters

leftSelector Func<TLeft, IEnumerableExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollection<TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLeftToRightOnlyLate<TValue>(Func<TLeft, IEnumerableExpression<TValue>>, Func<TRight, ICollection<TValue>>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeManyLeftToRightOnlyLate<TValue>(Func<TLeft, IEnumerableExpression<TValue>> leftSelector, Func<TRight, ICollection<TValue>> rightSelector, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Func<TLeft, IEnumerableExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollection<TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, IEnumerableExpression<TValue>>, Func<TRight, ICollection<TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, IEnumerableExpression<TValue>> leftSelector, Func<TRight, ICollection<TValue>> rightSelector)

Parameters

leftSelector Func<TLeft, IEnumerableExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollection<TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, IEnumerableExpression<TValue>>, Func<TRight, ICollection<TValue>>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, IEnumerableExpression<TValue>> leftSelector, Func<TRight, ICollection<TValue>> rightSelector, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Func<TLeft, IEnumerableExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollection<TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, ITransformationContext, IEnumerableExpression<TValue>>, Func<TRight, ITransformationContext, ICollection<TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, ITransformationContext, IEnumerableExpression<TValue>> leftSelector, Func<TRight, ITransformationContext, ICollection<TValue>> rightSelector)

Parameters

leftSelector Func<TLeft, ITransformationContext, IEnumerableExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ITransformationContext, ICollection<TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, ITransformationContext, IEnumerableExpression<TValue>>, Func<TRight, ITransformationContext, ICollection<TValue>>, Expression<Func<TLeft, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue> SynchronizeManyLeftToRightOnly<TValue>(Func<TLeft, ITransformationContext, IEnumerableExpression<TValue>> leftSelector, Func<TRight, ITransformationContext, ICollection<TValue>> rightSelector, Expression<Func<TLeft, bool>> guard)

Parameters

leftSelector Func<TLeft, ITransformationContext, IEnumerableExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ITransformationContext, ICollection<TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, IEnumerableExpression<TDepLeft>>>, Expression<Func<TRight, ICollection<TDepRight>>>)

Synchronizes the dependent elements using the provided synchronization rule but only Left to Right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight> SynchronizeManyLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, IEnumerableExpression<TDepLeft>>> leftSelector, Expression<Func<TRight, ICollection<TDepRight>>> rightSelector) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, IEnumerableExpression<TDepLeft>>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ICollection<TDepRight>>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeManyLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, IEnumerableExpression<TDepLeft>>>, Expression<Func<TRight, ITransformationContext, ICollection<TDepRight>>>)

Synchronizes the dependent elements using the provided synchronization rule but only Left to Right

public IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight> SynchronizeManyLeftToRightOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, IEnumerableExpression<TDepLeft>>> leftSelector, Expression<Func<TRight, ITransformationContext, ICollection<TDepRight>>> rightSelector) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, IEnumerableExpression<TDepLeft>>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, ICollection<TDepRight>>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxRight<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeManyRightToLeftOnlyLate<TValue>(Func<TLeft, ICollection<TValue>>, Func<TRight, IEnumerableExpression<TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeManyRightToLeftOnlyLate<TValue>(Func<TLeft, ICollection<TValue>> leftSelector, Func<TRight, IEnumerableExpression<TValue>> rightSelector)

Parameters

leftSelector Func<TLeft, ICollection<TValue>>

The LHS in-model lens

rightSelector Func<TRight, IEnumerableExpression<TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyRightToLeftOnlyLate<TValue>(Func<TLeft, ICollection<TValue>>, Func<TRight, IEnumerableExpression<TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeManyRightToLeftOnlyLate<TValue>(Func<TLeft, ICollection<TValue>> leftSelector, Func<TRight, IEnumerableExpression<TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftSelector Func<TLeft, ICollection<TValue>>

The LHS in-model lens

rightSelector Func<TRight, IEnumerableExpression<TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyRightToLeftOnly<TValue>(Func<TLeft, ICollection<TValue>>, Func<TRight, IEnumerableExpression<TValue>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeManyRightToLeftOnly<TValue>(Func<TLeft, ICollection<TValue>> leftSelector, Func<TRight, IEnumerableExpression<TValue>> rightSelector)

Parameters

leftSelector Func<TLeft, ICollection<TValue>>

The LHS in-model lens

rightSelector Func<TRight, IEnumerableExpression<TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyRightToLeftOnly<TValue>(Func<TLeft, ICollection<TValue>>, Func<TRight, IEnumerableExpression<TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only left to right

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeManyRightToLeftOnly<TValue>(Func<TLeft, ICollection<TValue>> leftSelector, Func<TRight, IEnumerableExpression<TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftSelector Func<TLeft, ICollection<TValue>>

The LHS in-model lens

rightSelector Func<TRight, IEnumerableExpression<TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeManyRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, ICollection<TDepLeft>>>, Expression<Func<TRight, ITransformationContext, IEnumerableExpression<TDepRight>>>)

Synchronizes the dependent elements using the provided synchronization rule but only Right to Left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight> SynchronizeManyRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, ICollection<TDepLeft>>> leftSelector, Expression<Func<TRight, ITransformationContext, IEnumerableExpression<TDepRight>>> rightSelector) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, ICollection<TDepLeft>>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, IEnumerableExpression<TDepRight>>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeManyRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ICollection<TDepLeft>>>, Expression<Func<TRight, IEnumerableExpression<TDepRight>>>)

Synchronizes the dependent elements using the provided synchronization rule but only Right to Left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight> SynchronizeManyRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ICollection<TDepLeft>>> leftSelector, Expression<Func<TRight, IEnumerableExpression<TDepRight>>> rightSelector) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ICollection<TDepLeft>>>

The LHS in-model lens

rightSelector Expression<Func<TRight, IEnumerableExpression<TDepRight>>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeMany<TValue>(Func<TLeft, ICollectionExpression<TValue>>, Func<TRight, ICollectionExpression<TValue>>)

Synchronizes the dependent values

public IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue> SynchronizeMany<TValue>(Func<TLeft, ICollectionExpression<TValue>> leftSelector, Func<TRight, ICollectionExpression<TValue>> rightSelector)

Parameters

leftSelector Func<TLeft, ICollectionExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollectionExpression<TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeMany<TValue>(Func<TLeft, ICollectionExpression<TValue>>, Func<TRight, ICollectionExpression<TValue>>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent values

public IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue> SynchronizeMany<TValue>(Func<TLeft, ICollectionExpression<TValue>> leftSelector, Func<TRight, ICollectionExpression<TValue>> rightSelector, Expression<Func<TLeft, TRight, bool>> guard)

Parameters

leftSelector Func<TLeft, ICollectionExpression<TValue>>

The LHS in-model lens

rightSelector Func<TRight, ICollectionExpression<TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of values

SynchronizeMany<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ICollectionExpression<TDepLeft>>>, Expression<Func<TRight, ICollectionExpression<TDepRight>>>)

Synchronizes the dependent elements using the provided synchronization rule

public IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight> SynchronizeMany<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ICollectionExpression<TDepLeft>>> leftSelector, Expression<Func<TRight, ICollectionExpression<TDepRight>>> rightSelector) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ICollectionExpression<TDepLeft>>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ICollectionExpression<TDepRight>>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeMany<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, ICollectionExpression<TDepLeft>>>, Expression<Func<TRight, ITransformationContext, ICollectionExpression<TDepRight>>>)

Synchronizes the dependent elements using the provided synchronization rule

public IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight> SynchronizeMany<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, ICollectionExpression<TDepLeft>>> leftSelector, Expression<Func<TRight, ITransformationContext, ICollectionExpression<TDepRight>>> rightSelector) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, ICollectionExpression<TDepLeft>>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, ICollectionExpression<TDepRight>>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeOpaque(Action<TLeft, TRight, SynchronizationDirection, ISynchronizationContext>, bool)

Executes the given action when a correspondence between LHS and RHS elements is established

public void SynchronizeOpaque(Action<TLeft, TRight, SynchronizationDirection, ISynchronizationContext> action, bool isEarly = false)

Parameters

action Action<TLeft, TRight, SynchronizationDirection, ISynchronizationContext>

The action to perform

isEarly bool

True, if the synchronization job should be performed before dependencies, otherwise False

SynchronizeOpaque(Func<TLeft, TRight, SynchronizationDirection, ISynchronizationContext, IDisposable>, bool)

Executes the given action when a correspondence between LHS and RHS elements is established

public void SynchronizeOpaque(Func<TLeft, TRight, SynchronizationDirection, ISynchronizationContext, IDisposable> action, bool isEarly = false)

Parameters

action Func<TLeft, TRight, SynchronizationDirection, ISynchronizationContext, IDisposable>

The action to perform

isEarly bool

True, if the synchronization job should be performed before dependencies, otherwise False

SynchronizeRightToLeftOnly<TValue>(Action<TLeft, ITransformationContext, TValue>, Expression<Func<TRight, ITransformationContext, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Action<TLeft, ITransformationContext, TValue> leftSetter, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector)

Parameters

leftSetter Action<TLeft, ITransformationContext, TValue>

A LHS setter

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Action<TLeft, ITransformationContext, TValue>, Expression<Func<TRight, ITransformationContext, TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Action<TLeft, ITransformationContext, TValue> leftSetter, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftSetter Action<TLeft, ITransformationContext, TValue>

A LHS setter

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Action<TLeft, TValue>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Action<TLeft, TValue> leftSetter, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSetter Action<TLeft, TValue>

A LHS setter

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Action<TLeft, TValue>, Expression<Func<TRight, TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Action<TLeft, TValue> leftSetter, Expression<Func<TRight, TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftSetter Action<TLeft, TValue>

A LHS setter

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Func<TLeft, ITransformationContext, TValue>, Action<TLeft, ITransformationContext, TValue>, Expression<Func<TRight, ITransformationContext, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Func<TLeft, ITransformationContext, TValue> leftGetter, Action<TLeft, ITransformationContext, TValue> leftSetter, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector)

Parameters

leftGetter Func<TLeft, ITransformationContext, TValue>

A LHS getter

leftSetter Action<TLeft, ITransformationContext, TValue>

A LHS setter

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Func<TLeft, ITransformationContext, TValue>, Action<TLeft, ITransformationContext, TValue>, Expression<Func<TRight, ITransformationContext, TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Func<TLeft, ITransformationContext, TValue> leftGetter, Action<TLeft, ITransformationContext, TValue> leftSetter, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftGetter Func<TLeft, ITransformationContext, TValue>

A LHS getter

leftSetter Action<TLeft, ITransformationContext, TValue>

A LHS setter

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Func<TLeft, TValue>, Action<TLeft, TValue>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Func<TLeft, TValue> leftGetter, Action<TLeft, TValue> leftSetter, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftGetter Func<TLeft, TValue>

A LHS getter

leftSetter Action<TLeft, TValue>

A LHS setter

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Func<TLeft, TValue>, Action<TLeft, TValue>, Expression<Func<TRight, TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Func<TLeft, TValue> leftGetter, Action<TLeft, TValue> leftSetter, Expression<Func<TRight, TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftGetter Func<TLeft, TValue>

A LHS getter

leftSetter Action<TLeft, TValue>

A LHS setter

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>>, Expression<Func<TRight, ITransformationContext, TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Expression<Func<TLeft, ITransformationContext, TValue>> leftSelector, Expression<Func<TRight, ITransformationContext, TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, ITransformationContext, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent values but only right to left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue> SynchronizeRightToLeftOnly<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector, Expression<Func<TRight, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

SynchronizeRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, TDepLeft>>, Expression<Func<TRight, ITransformationContext, TDepRight>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule but only Right to Left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight> SynchronizeRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, TDepLeft>> leftSelector, Expression<Func<TRight, ITransformationContext, TDepRight>> rightSelector, Expression<Func<TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TDepRight>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

SynchronizeRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, TDepLeft>>, Expression<Func<TRight, TDepRight>>, Expression<Func<TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule but only Right to Left

public IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight> SynchronizeRightToLeftOnly<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, TDepLeft>> leftSelector, Expression<Func<TRight, TDepRight>> rightSelector, Expression<Func<TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TDepRight>>

The RHS in-model lens

guard Expression<Func<TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntaxLeft<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>)

Synchronizes the dependent values

public IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue> Synchronize<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

Synchronize<TValue>(Expression<Func<TLeft, TValue>>, Expression<Func<TRight, TValue>>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent values

public IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue> Synchronize<TValue>(Expression<Func<TLeft, TValue>> leftSelector, Expression<Func<TRight, TValue>> rightSelector, Expression<Func<TLeft, TRight, bool>> guard)

Parameters

leftSelector Expression<Func<TLeft, TValue>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TValue>>

The RHS in-model lens

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TValue, TValue>

Type Parameters

TValue

The type of the values

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, TDepLeft>>, Action<TLeft, ITransformationContext, TDepLeft>, Expression<Func<TRight, ITransformationContext, TDepRight>>, Action<TRight, ITransformationContext, TDepRight>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight> Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, TDepLeft>> leftSelector, Action<TLeft, ITransformationContext, TDepLeft> leftSetter, Expression<Func<TRight, ITransformationContext, TDepRight>> rightSelector, Action<TRight, ITransformationContext, TDepRight> rightSetter, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, TDepLeft>>

The LHS in-model lens

leftSetter Action<TLeft, ITransformationContext, TDepLeft>

An alternative LHS lens put

rightSelector Expression<Func<TRight, ITransformationContext, TDepRight>>

The RHS in-model lens

rightSetter Action<TRight, ITransformationContext, TDepRight>

An alternative RHS lens put

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, TDepLeft>>, Action<TLeft, ITransformationContext, TDepLeft>, Expression<Func<TRight, ITransformationContext, TDepRight>>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public void Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, TDepLeft>> leftSelector, Action<TLeft, ITransformationContext, TDepLeft> leftSetter, Expression<Func<TRight, ITransformationContext, TDepRight>> rightSelector, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, TDepLeft>>

The LHS in-model lens

leftSetter Action<TLeft, ITransformationContext, TDepLeft>

An alternative LHS lens put

rightSelector Expression<Func<TRight, ITransformationContext, TDepRight>>

The RHS in-model lens

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, TDepLeft>>, Expression<Func<TRight, ITransformationContext, TDepRight>>, Action<TRight, ITransformationContext, TDepRight>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight> Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, TDepLeft>> leftSelector, Expression<Func<TRight, ITransformationContext, TDepRight>> rightSelector, Action<TRight, ITransformationContext, TDepRight> rightSetter, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TDepRight>>

The RHS in-model lens

rightSetter Action<TRight, ITransformationContext, TDepRight>

An alternative RHS lens put

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, ITransformationContext, TDepLeft>>, Expression<Func<TRight, ITransformationContext, TDepRight>>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public void Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, ITransformationContext, TDepLeft>> leftSelector, Expression<Func<TRight, ITransformationContext, TDepRight>> rightSelector, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, ITransformationContext, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, ITransformationContext, TDepRight>>

The RHS in-model lens

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, TDepLeft>>, Action<TLeft, TDepLeft>, Expression<Func<TRight, TDepRight>>, Action<TRight, TDepRight>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight> Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, TDepLeft>> leftSelector, Action<TLeft, TDepLeft> leftSetter, Expression<Func<TRight, TDepRight>> rightSelector, Action<TRight, TDepRight> rightSetter, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, TDepLeft>>

The LHS in-model lens

leftSetter Action<TLeft, TDepLeft>

An alternative LHS lens put

rightSelector Expression<Func<TRight, TDepRight>>

The RHS in-model lens

rightSetter Action<TRight, TDepRight>

An alternative RHS lens put

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, TDepLeft>>, Action<TLeft, TDepLeft>, Expression<Func<TRight, TDepRight>>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public void Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, TDepLeft>> leftSelector, Action<TLeft, TDepLeft> leftSetter, Expression<Func<TRight, TDepRight>> rightSelector, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, TDepLeft>>

The LHS in-model lens

leftSetter Action<TLeft, TDepLeft>

An alternative LHS lens put

rightSelector Expression<Func<TRight, TDepRight>>

The RHS in-model lens

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, TDepLeft>>, Expression<Func<TRight, TDepRight>>, Action<TRight, TDepRight>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight> Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, TDepLeft>> leftSelector, Expression<Func<TRight, TDepRight>> rightSelector, Action<TRight, TDepRight> rightSetter, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TDepRight>>

The RHS in-model lens

rightSetter Action<TRight, TDepRight>

An alternative RHS lens put

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Returns

IInconsistencyDescriptorSyntax<TLeft, TRight, TDepLeft, TDepRight>

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type

Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight>, Expression<Func<TLeft, TDepLeft>>, Expression<Func<TRight, TDepRight>>, Expression<Func<TLeft, TRight, bool>>)

Synchronizes the dependent elements using the provided synchronization rule

public void Synchronize<TDepLeft, TDepRight>(SynchronizationRule<TDepLeft, TDepRight> rule, Expression<Func<TLeft, TDepLeft>> leftSelector, Expression<Func<TRight, TDepRight>> rightSelector, Expression<Func<TLeft, TRight, bool>> guard = null) where TDepLeft : class where TDepRight : class

Parameters

rule SynchronizationRule<TDepLeft, TDepRight>

The rule that should be used as isomorphism

leftSelector Expression<Func<TLeft, TDepLeft>>

The LHS in-model lens

rightSelector Expression<Func<TRight, TDepRight>>

The RHS in-model lens

guard Expression<Func<TLeft, TRight, bool>>

A guard condition or null

Type Parameters

TDepLeft

The dependent LHS type

TDepRight

The dependent RHS type