Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / ndp / fx / src / DataEntity / System / Data / Common / internal / materialization / coordinatorfactory.cs / 1 / coordinatorfactory.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
namespace System.Data.Common.Internal.Materialization
{
///
/// An immutable class used to generate new coordinators. These coordinators are used
/// at runtime to materialize results.
///
internal abstract class CoordinatorFactory
{
#region statics
///
/// Function of shaper that returns true; one default case when there is no explicit predicate.
///
private static readonly Func AlwaysTrue = s => true;
///
/// Function of shaper that returns false; one default case used when there is no explicit predicate.
///
private static readonly Func AlwaysFalse = s => false;
#endregion
#region state
///
/// Gets depth of the reader (0 is top-level -- which incidentally doesn't
/// require a coordinator...
///
internal readonly int Depth;
///
/// Indicates which state slot in the Shaper.State is expected to hold the
/// value for this nested reader result.
///
internal readonly int StateSlot;
///
/// A function determining whether the current row has data for this nested result.
///
internal readonly Func HasData;
///
/// A function setting key values. (the return value is irrelevant)
///
internal readonly Func SetKeys;
///
/// A function returning true if key values match the previously set values.
///
internal readonly Func CheckKeys;
///
/// Nested results below this (at depth + 1)
///
internal readonly System.Collections.ObjectModel.ReadOnlyCollection NestedCoordinators;
///
/// Indicates whether this is a leaf reader.
///
internal readonly bool IsLeafResult;
///
/// Indicates whether this coordinator can be managed by a simple enumerator. A simple enumerator
/// returns a single element per row, so the following conditions disqualify the enumerator:
/// nested collections, data discriminators (not all rows have data), keys (not all rows have new data).
///
internal readonly bool IsSimple;
///
/// For value-layer queries, the factories for all the records that we can potentially process
/// at this level in the query result.
///
internal readonly System.Collections.ObjectModel.ReadOnlyCollection RecordStateFactories;
#endregion
#region constructor
protected CoordinatorFactory(int depth, int stateSlot, Func hasData, Func setKeys, Func checkKeys, CoordinatorFactory[] nestedCoordinators, RecordStateFactory[] recordStateFactories)
{
this.Depth = depth;
this.StateSlot = stateSlot;
// figure out if there are any nested coordinators
this.IsLeafResult = 0 == nestedCoordinators.Length;
// if there is no explicit 'has data' discriminator, it means all rows contain data for the coordinator
if (hasData == null)
{
this.HasData = AlwaysTrue;
}
else
{
this.HasData = hasData;
}
// if there is no explicit set key delegate, just return true (the value is not used anyways)
if (setKeys == null)
{
this.SetKeys = AlwaysTrue;
}
else
{
this.SetKeys = setKeys;
}
// If there are no keys, it means different things depending on whether we are a leaf
// coordinator or an inner (or 'driving') coordinator. For a leaf coordinator, it means
// that every row is a new result. For an inner coordinator, it means that there is no
// key to check. This should only occur where there is a SingleRowTable (in other words,
// all rows are elements of a single child collection).
if (checkKeys == null)
{
if (this.IsLeafResult)
{
this.CheckKeys = AlwaysFalse; // every row is a new result (the keys don't match)
}
else
{
this.CheckKeys = AlwaysTrue; // every row belongs to a single child collection
}
}
else
{
this.CheckKeys = checkKeys;
}
this.NestedCoordinators = new System.Collections.ObjectModel.ReadOnlyCollection(nestedCoordinators);
this.RecordStateFactories = new System.Collections.ObjectModel.ReadOnlyCollection(recordStateFactories);
// Determines whether this coordinator can be handled by a 'simple' enumerator. See IsSimple for details.
this.IsSimple = IsLeafResult && null == checkKeys && null == hasData;
}
#endregion
#region "public" surface area
///
/// Creates a buffer handling state needed by this coordinator.
///
internal abstract Coordinator CreateCoordinator(Coordinator parent, Coordinator next);
#endregion
}
///
/// Typed
internal sealed class CoordinatorFactory : CoordinatorFactory
{
#region state
///
/// Reads a single element of the result from the given reader state object.
///
internal readonly Func Element;
///
/// Same as Element but uses slower patterns to provide better exception messages (e.g.
/// using reader.GetValue + type check rather than reader.GetInt32)
///
internal readonly Func ElementWithErrorHandling;
///
/// Description of this CoordinatorFactory, used for debugging only; while this is not
/// needed in retail code, it is pretty important because it's the only description we'll
/// have once we compile the Expressions; debugging a problem with retail bits would be
/// pretty hard without this.
///
private readonly string Description;
#endregion
#region constructor
public CoordinatorFactory(int depth, int stateSlot, Expression hasData, Expression setKeys, Expression checkKeys, CoordinatorFactory[] nestedCoordinators, Expression element, Expression elementWithErrorHandling, RecordStateFactory[] recordStateFactories)
: base(depth, stateSlot, CompilePredicate(hasData), CompilePredicate(setKeys), CompilePredicate(checkKeys), nestedCoordinators, recordStateFactories)
{
this.Element = Translator.Compile(element);
this.ElementWithErrorHandling = Translator.Compile(elementWithErrorHandling);
this.Description = new StringBuilder()
.Append("HasData: ")
.AppendLine(DescribeExpression(hasData))
.Append("SetKeys: ")
.AppendLine(DescribeExpression(setKeys))
.Append("CheckKeys: ")
.AppendLine(DescribeExpression(checkKeys))
.Append("Element: ")
.AppendLine(DescribeExpression(element))
.Append("ElementWithExceptionHandling: ")
.AppendLine(DescribeExpression(elementWithErrorHandling))
.ToString();
}
#endregion
#region expression helpers
///
/// Return the compiled expression for the predicate
///
private static Func CompilePredicate(Expression predicate)
{
Func result;
if (null == predicate)
{
result = null;
}
else
{
result = Translator.Compile(predicate);
}
return result;
}
///
/// Returns a string representation of the expression
///
private static string DescribeExpression(Expression expression)
{
string result;
if (null == expression)
{
result = "undefined";
}
else
{
result = expression.ToString();
}
return result;
}
#endregion
#region "public" surface area
///
/// Create a coordinator used for materialization of collections. Unlike the CoordinatorFactory,
/// the Coordinator contains mutable state.
///
internal override Coordinator CreateCoordinator(Coordinator parent, Coordinator next)
{
return new Coordinator(this, parent, next);
}
///
/// Returns the "default" record state (that is, the one we use for PreRead/PastEnd reader states
///
internal RecordState GetDefaultRecordState(Shaper shaper)
{
RecordState result = null;
if (this.RecordStateFactories.Count > 0)
{
//
result = (RecordState)shaper.State[this.RecordStateFactories[0].StateSlotNumber];
Debug.Assert(null != result, "did you initialize the record states?");
result.ResetToDefaultState();
}
return result;
}
public override string ToString()
{
return Description;
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
namespace System.Data.Common.Internal.Materialization
{
///
/// An immutable class used to generate new coordinators. These coordinators are used
/// at runtime to materialize results.
///
internal abstract class CoordinatorFactory
{
#region statics
///
/// Function of shaper that returns true; one default case when there is no explicit predicate.
///
private static readonly Func AlwaysTrue = s => true;
///
/// Function of shaper that returns false; one default case used when there is no explicit predicate.
///
private static readonly Func AlwaysFalse = s => false;
#endregion
#region state
///
/// Gets depth of the reader (0 is top-level -- which incidentally doesn't
/// require a coordinator...
///
internal readonly int Depth;
///
/// Indicates which state slot in the Shaper.State is expected to hold the
/// value for this nested reader result.
///
internal readonly int StateSlot;
///
/// A function determining whether the current row has data for this nested result.
///
internal readonly Func HasData;
///
/// A function setting key values. (the return value is irrelevant)
///
internal readonly Func SetKeys;
///
/// A function returning true if key values match the previously set values.
///
internal readonly Func CheckKeys;
///
/// Nested results below this (at depth + 1)
///
internal readonly System.Collections.ObjectModel.ReadOnlyCollection NestedCoordinators;
///
/// Indicates whether this is a leaf reader.
///
internal readonly bool IsLeafResult;
///
/// Indicates whether this coordinator can be managed by a simple enumerator. A simple enumerator
/// returns a single element per row, so the following conditions disqualify the enumerator:
/// nested collections, data discriminators (not all rows have data), keys (not all rows have new data).
///
internal readonly bool IsSimple;
///
/// For value-layer queries, the factories for all the records that we can potentially process
/// at this level in the query result.
///
internal readonly System.Collections.ObjectModel.ReadOnlyCollection RecordStateFactories;
#endregion
#region constructor
protected CoordinatorFactory(int depth, int stateSlot, Func hasData, Func setKeys, Func checkKeys, CoordinatorFactory[] nestedCoordinators, RecordStateFactory[] recordStateFactories)
{
this.Depth = depth;
this.StateSlot = stateSlot;
// figure out if there are any nested coordinators
this.IsLeafResult = 0 == nestedCoordinators.Length;
// if there is no explicit 'has data' discriminator, it means all rows contain data for the coordinator
if (hasData == null)
{
this.HasData = AlwaysTrue;
}
else
{
this.HasData = hasData;
}
// if there is no explicit set key delegate, just return true (the value is not used anyways)
if (setKeys == null)
{
this.SetKeys = AlwaysTrue;
}
else
{
this.SetKeys = setKeys;
}
// If there are no keys, it means different things depending on whether we are a leaf
// coordinator or an inner (or 'driving') coordinator. For a leaf coordinator, it means
// that every row is a new result. For an inner coordinator, it means that there is no
// key to check. This should only occur where there is a SingleRowTable (in other words,
// all rows are elements of a single child collection).
if (checkKeys == null)
{
if (this.IsLeafResult)
{
this.CheckKeys = AlwaysFalse; // every row is a new result (the keys don't match)
}
else
{
this.CheckKeys = AlwaysTrue; // every row belongs to a single child collection
}
}
else
{
this.CheckKeys = checkKeys;
}
this.NestedCoordinators = new System.Collections.ObjectModel.ReadOnlyCollection(nestedCoordinators);
this.RecordStateFactories = new System.Collections.ObjectModel.ReadOnlyCollection(recordStateFactories);
// Determines whether this coordinator can be handled by a 'simple' enumerator. See IsSimple for details.
this.IsSimple = IsLeafResult && null == checkKeys && null == hasData;
}
#endregion
#region "public" surface area
///
/// Creates a buffer handling state needed by this coordinator.
///
internal abstract Coordinator CreateCoordinator(Coordinator parent, Coordinator next);
#endregion
}
///
/// Typed
internal sealed class CoordinatorFactory : CoordinatorFactory
{
#region state
///
/// Reads a single element of the result from the given reader state object.
///
internal readonly Func Element;
///
/// Same as Element but uses slower patterns to provide better exception messages (e.g.
/// using reader.GetValue + type check rather than reader.GetInt32)
///
internal readonly Func ElementWithErrorHandling;
///
/// Description of this CoordinatorFactory, used for debugging only; while this is not
/// needed in retail code, it is pretty important because it's the only description we'll
/// have once we compile the Expressions; debugging a problem with retail bits would be
/// pretty hard without this.
///
private readonly string Description;
#endregion
#region constructor
public CoordinatorFactory(int depth, int stateSlot, Expression hasData, Expression setKeys, Expression checkKeys, CoordinatorFactory[] nestedCoordinators, Expression element, Expression elementWithErrorHandling, RecordStateFactory[] recordStateFactories)
: base(depth, stateSlot, CompilePredicate(hasData), CompilePredicate(setKeys), CompilePredicate(checkKeys), nestedCoordinators, recordStateFactories)
{
this.Element = Translator.Compile(element);
this.ElementWithErrorHandling = Translator.Compile(elementWithErrorHandling);
this.Description = new StringBuilder()
.Append("HasData: ")
.AppendLine(DescribeExpression(hasData))
.Append("SetKeys: ")
.AppendLine(DescribeExpression(setKeys))
.Append("CheckKeys: ")
.AppendLine(DescribeExpression(checkKeys))
.Append("Element: ")
.AppendLine(DescribeExpression(element))
.Append("ElementWithExceptionHandling: ")
.AppendLine(DescribeExpression(elementWithErrorHandling))
.ToString();
}
#endregion
#region expression helpers
///
/// Return the compiled expression for the predicate
///
private static Func CompilePredicate(Expression predicate)
{
Func result;
if (null == predicate)
{
result = null;
}
else
{
result = Translator.Compile(predicate);
}
return result;
}
///
/// Returns a string representation of the expression
///
private static string DescribeExpression(Expression expression)
{
string result;
if (null == expression)
{
result = "undefined";
}
else
{
result = expression.ToString();
}
return result;
}
#endregion
#region "public" surface area
///
/// Create a coordinator used for materialization of collections. Unlike the CoordinatorFactory,
/// the Coordinator contains mutable state.
///
internal override Coordinator CreateCoordinator(Coordinator parent, Coordinator next)
{
return new Coordinator(this, parent, next);
}
///
/// Returns the "default" record state (that is, the one we use for PreRead/PastEnd reader states
///
internal RecordState GetDefaultRecordState(Shaper shaper)
{
RecordState result = null;
if (this.RecordStateFactories.Count > 0)
{
//
result = (RecordState)shaper.State[this.RecordStateFactories[0].StateSlotNumber];
Debug.Assert(null != result, "did you initialize the record states?");
result.ResetToDefaultState();
}
return result;
}
public override string ToString()
{
return Description;
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SweepDirectionValidation.cs
- RuleSetBrowserDialog.cs
- ActionFrame.cs
- ContentPresenter.cs
- EntityCommandCompilationException.cs
- AttachInfo.cs
- TreeNodeMouseHoverEvent.cs
- dataobject.cs
- DataProtection.cs
- CodeAttributeArgument.cs
- MemberInfoSerializationHolder.cs
- HttpCachePolicy.cs
- ContainerParaClient.cs
- OptimizerPatterns.cs
- XamlSerializer.cs
- StringStorage.cs
- BindValidator.cs
- ProtocolInformationReader.cs
- __Filters.cs
- DataSourceUtil.cs
- IERequestCache.cs
- Mappings.cs
- ButtonFlatAdapter.cs
- InvariantComparer.cs
- ColorAnimation.cs
- StaticExtension.cs
- ParameterReplacerVisitor.cs
- FunctionMappingTranslator.cs
- DockPatternIdentifiers.cs
- MsmqChannelFactoryBase.cs
- ResourceContainerWrapper.cs
- ActivityDesignerResources.cs
- FrameworkObject.cs
- wgx_sdk_version.cs
- FileRegion.cs
- BooleanAnimationBase.cs
- IUnknownConstantAttribute.cs
- MemberRelationshipService.cs
- PointCollectionConverter.cs
- TimersDescriptionAttribute.cs
- Int32EqualityComparer.cs
- EventQueueState.cs
- Symbol.cs
- KnownIds.cs
- ControlCodeDomSerializer.cs
- CellTreeNodeVisitors.cs
- UIElement3DAutomationPeer.cs
- GlyphsSerializer.cs
- TableFieldsEditor.cs
- XmlSchemaGroup.cs
- input.cs
- InheritablePropertyChangeInfo.cs
- LayoutDump.cs
- Font.cs
- RowBinding.cs
- InternalConfigRoot.cs
- ToolboxDataAttribute.cs
- KeyboardDevice.cs
- XmlTextAttribute.cs
- ConfigurationPermission.cs
- safelinkcollection.cs
- EdmPropertyAttribute.cs
- DataGridViewCellConverter.cs
- TextRange.cs
- PerformanceCounterPermissionEntryCollection.cs
- OracleException.cs
- SizeAnimationUsingKeyFrames.cs
- WindowsStartMenu.cs
- NominalTypeEliminator.cs
- SafeFreeMibTable.cs
- ZipIOLocalFileHeader.cs
- TreeNodeEventArgs.cs
- WindowsEditBox.cs
- ArraySet.cs
- SemanticKeyElement.cs
- UnknownBitmapDecoder.cs
- figurelength.cs
- TransformerTypeCollection.cs
- SecurityTokenProvider.cs
- MatrixTransform3D.cs
- ContentElement.cs
- SQLCharsStorage.cs
- QueryAccessibilityHelpEvent.cs
- TemplateControlBuildProvider.cs
- DbProviderFactories.cs
- XmlAnyAttributeAttribute.cs
- RelationalExpressions.cs
- PriorityChain.cs
- TimelineGroup.cs
- PagesSection.cs
- PlainXmlDeserializer.cs
- DesignerWidgets.cs
- DriveInfo.cs
- ValueSerializerAttribute.cs
- PolicyConversionContext.cs
- ManagementObjectCollection.cs
- CngUIPolicy.cs
- ToggleButtonAutomationPeer.cs
- SoapReflectionImporter.cs
- RefreshEventArgs.cs