/// <summary>
/// Builds the <see cref="QueryDataSet"/> from the specified container data and query queryRepository.
/// </summary>
/// <param name="rootDataTypeMap">The collection of rootDataTypes used to build the data set.</param>
/// <param name="entityContainerData">Entity Container Data</param>
/// <returns>
/// Instance of <see cref="QueryDataSet"/> with data populated from the containerData
/// </returns>
public virtual IQueryDataSet Build(IDictionary <string, QueryStructuralType> rootDataTypeMap, EntityContainerData entityContainerData)
{
QueryDataSet dataSet = new QueryDataSet();
this.rootDataTypes = rootDataTypeMap;
this.rowInstances = new Dictionary <string, Dictionary <EntityDataKey, QueryStructuralValue> >();
if (null != entityContainerData)
{
// phase 1 - build stub QueryStructuralValues for each EntityDataSetRow
// and create result collections. We're doing it in two phases so that we
// can set up relationships more easily since all objects
// are guaranteed to exist.
foreach (var entitySet in entityContainerData.EntityContainer.EntitySets)
{
var entitySetData = entityContainerData.GetEntitySetData(entitySet.Name);
var collection = this.BuildStubEntities(entitySetData);
dataSet.RootQueryData[entitySet.Name] = collection;
}
// phase 2 - copy actual data into pre-generated objects
foreach (var entitySet in entityContainerData.EntityContainer.EntitySets)
{
var entitySetData = entityContainerData.GetEntitySetData(entitySet.Name);
this.PopulateObjectInstances(entitySetData);
}
}
return(dataSet);
}
/// <summary>
/// Converts the serializable container (WCF proxy classes) into EntityContainerData.
/// </summary>
/// <param name="modelSchema">The model schema.</param>
/// <param name="serializableContainer">The serializable container.</param>
/// <returns>
/// Instance of <see cref="EntityContainerData"/>
/// </returns>
public EntityContainerData Convert(EntityModelSchema modelSchema, SerializableContainer serializableContainer)
{
ExceptionUtilities.CheckArgumentNotNull(modelSchema, "modelSchema");
ExceptionUtilities.CheckArgumentNotNull(serializableContainer, "serializableContainer");
var container = modelSchema.EntityContainers.Single(c => c.Name == serializableContainer.EntityContainerName);
var data = new EntityContainerData(container);
var rowMap = new Dictionary<SerializableEntity, EntitySetDataRow>();
foreach (var entity in serializableContainer.Entities)
{
var setData = data.GetEntitySetData(entity.EntitySetName);
EntitySetDataRow row;
if (entity.Streams != null)
{
var entityType = modelSchema.EntityTypes.Single(t => t.FullName == entity.EntityType);
var rowWithStreams = new EntitySetDataRowWithStreams(setData, entityType);
row = rowWithStreams;
setData.Rows.Add(row);
foreach (var stream in entity.Streams)
{
rowWithStreams.Streams.Add(ConvertStreamData(stream));
}
}
else
{
row = setData.AddNewRowOfType(entity.EntityType);
}
rowMap.Add(entity, row);
}
foreach (var entity in serializableContainer.Entities)
{
this.ConvertEntityProperty(entity, data, rowMap);
}
return data;
}
/// <summary>
/// Converts the serializable container (WCF proxy classes) into EntityContainerData.
/// </summary>
/// <param name="modelSchema">The model schema.</param>
/// <param name="serializableContainer">The serializable container.</param>
/// <returns>
/// Instance of <see cref="EntityContainerData"/>
/// </returns>
public EntityContainerData Convert(EntityModelSchema modelSchema, SerializableContainer serializableContainer)
{
ExceptionUtilities.CheckArgumentNotNull(modelSchema, "modelSchema");
ExceptionUtilities.CheckArgumentNotNull(serializableContainer, "serializableContainer");
var container = modelSchema.EntityContainers.Single(c => c.Name == serializableContainer.EntityContainerName);
var data = new EntityContainerData(container);
var rowMap = new Dictionary <SerializableEntity, EntitySetDataRow>();
foreach (var entity in serializableContainer.Entities)
{
var setData = data.GetEntitySetData(entity.EntitySetName);
EntitySetDataRow row;
if (entity.Streams != null)
{
var entityType = modelSchema.EntityTypes.Single(t => t.FullName == entity.EntityType);
var rowWithStreams = new EntitySetDataRowWithStreams(setData, entityType);
row = rowWithStreams;
setData.Rows.Add(row);
foreach (var stream in entity.Streams)
{
rowWithStreams.Streams.Add(ConvertStreamData(stream));
}
}
else
{
row = setData.AddNewRowOfType(entity.EntityType);
}
rowMap.Add(entity, row);
}
foreach (var entity in serializableContainer.Entities)
{
this.ConvertEntityProperty(entity, data, rowMap);
}
return(data);
}
/// <summary>
/// Examines the required relationships from <paramref name="source"/> and then populates them in <paramref name="graph"/>.
/// </summary>
/// <param name="graph">The <see cref="List{IEntitySetData}"/> to which to add the new instance.</param>
/// <param name="source">The entity from which to find required relationships and populate them.</param>
/// <param name="sourceEntitySet">The <see cref="EntitySet"/> in which <paramref name="source"/> resides.</param>
/// <param name="sourceEntityType">The <see cref="EntityType"/> of which the <paramref name="source"/> is an instance.</param>
/// <param name="sourceKey">The <see cref="EntityDataKey"/> of the <paramref name="source"/> instance.</param>
/// <param name="data"><see cref="EntityContainerData"/> that contains the structural data from which to create objects.</param>
/// <param name="processedEntities">The entity instances which have been translated from structural data into objects.</param>
/// <param name="processedAssociations">The association instances which have been translated from structural data into calls to <paramref name="connectEntities"/>.</param>
/// <param name="entityCreated">A callback function invoked every time a new entity instance is created and its properties are initialized.</param>
/// <param name="connectEntities">A callback used to connect two objects together. Examples of actions include setting navigation properties,
/// synchronizing FKs to PK values, and/or using the IRelatedEnd or SetLink APIs. The first two parameters are the objects that need to
/// be connected, and the third is the <see cref="RelationshipSide"/> describing the side of the relationship which the first object participates
/// in.</param>
private void CreateGraphCore(
List <IEntitySetData> graph,
IEntitySetData source,
EntitySet sourceEntitySet,
EntityType sourceEntityType,
EntityDataKey sourceKey,
EntityContainerData data,
Dictionary <EntityKey, IEntitySetData> processedEntities,
HashSet <AssociationInstance> processedAssociations,
Action <IEntitySetData> entityCreated,
ConnectEntitiesCallback connectEntities)
{
var requiredRelationships =
from r in sourceEntitySet.Container.RelationshipTypes()
let side = r.Sides.FirstOrDefault(e =>
sourceEntityType.IsKindOf(e.FromEntityType) &&
sourceEntitySet == e.FromEntitySet &&
e.ToMultiplicity == EndMultiplicity.One)
where side != null
select new
{
Relationship = r,
SourceSide = side
};
foreach (var r in requiredRelationships)
{
var relationship = r.Relationship;
var sourceSide = r.SourceSide;
var associationRow = data.GetAssociationSetData(relationship.AssociationSet.Name).Rows
.Single(row => row.GetRoleKey(sourceSide.FromRoleName).Equals(sourceKey));
var targetKey = associationRow.GetRoleKey(sourceSide.ToRoleName);
var targetEntitySet = sourceSide.ToEntitySet;
var targetEntityKey = new EntityKey(targetEntitySet.ContainerQualifiedName, targetKey);
IEntitySetData targetEntity;
if (!processedEntities.TryGetValue(targetEntityKey, out targetEntity))
{
var targetRow = data.GetEntitySetData(targetEntitySet.Name).Rows.Single(row => row.Key.Equals(targetKey));
targetEntity = this.CreateObjectFromRow(targetRow);
if (entityCreated != null)
{
entityCreated(targetEntity);
}
graph.Add(targetEntity);
processedEntities.Add(targetEntityKey, targetEntity);
InvokeConnectEntitiesCallback(source, targetEntity, relationship, sourceSide, processedAssociations, connectEntities);
this.CreateGraphCore(
graph,
targetEntity,
targetEntitySet,
targetRow.EntityType,
targetKey,
data,
processedEntities,
processedAssociations,
entityCreated,
connectEntities);
}
else
{
InvokeConnectEntitiesCallback(source, targetEntity, relationship, sourceSide, processedAssociations, connectEntities);
}
}
}
