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

SynchronizeCollectionsLeftToRight(ICollection<TRight>, ICollection<TLeft>, ISynchronizationContext, bool)

Synchronizes collections of LHS and RHS elements in the direction lefts to rights

protected virtual void SynchronizeCollectionsLeftToRight(ICollection<TRight> rights, ICollection<TLeft> lefts, ISynchronizationContext context, bool ignoreCandidates)

Parameters

rights ICollection<TRight>

The right elements

lefts ICollection<TLeft>

The left elements

context ISynchronizationContext

The synchronization context

ignoreCandidates bool

True, if candidates can be ignored, otherwise false

SynchronizeCollectionsRightToLeft(ICollection<TLeft>, ICollection<TRight>, ISynchronizationContext, bool)

Synchronizes collections of LHS and RHS elements in the direction rights to lefts

protected virtual void SynchronizeCollectionsRightToLeft(ICollection<TLeft> lefts, ICollection<TRight> rights, ISynchronizationContext context, bool ignoreCandidates)

Parameters

lefts ICollection<TLeft>

The left elements

rights ICollection<TRight>

The right elements

context ISynchronizationContext

The synchronization context

ignoreCandidates bool

True, if candidates can be ignored, otherwise false

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

Synchronizes the dependent values but only left to right

public void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

Type Parameters

TValue

The type of the values

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

Synchronizes the dependent values late

public void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 void 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

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 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, 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

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 void 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

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 void 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

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 void 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

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