public void SetUp()
{
_mutableTypeBatchCodeGenerator = MockRepository.GenerateStrictMock <IMutableTypeBatchCodeGenerator>();
_generatedCodeFlusher = MockRepository.GenerateStrictMock <IGeneratedCodeFlusher>();
_assemblyContext = new AssemblyContext(_mutableTypeBatchCodeGenerator, _generatedCodeFlusher);
}
public AssemblyContext(IMutableTypeBatchCodeGenerator mutableTypeBatchCodeGenerator, IGeneratedCodeFlusher generatedCodeFlusher)
{
ArgumentUtility.CheckNotNull("mutableTypeBatchCodeGenerator", mutableTypeBatchCodeGenerator);
ArgumentUtility.CheckNotNull("generatedCodeFlusher", generatedCodeFlusher);
_mutableTypeBatchCodeGenerator = mutableTypeBatchCodeGenerator;
_generatedCodeFlusher = generatedCodeFlusher;
ResetParticipantState();
}
private GeneratedTypesContext GenerateTypesWithDiagnostics(
IMutableTypeBatchCodeGenerator codeGenerator, IEnumerable <MutableType> mutableTypes, string generationSubjectName)
{
try
{
var generatedTypes = codeGenerator.GenerateTypes(mutableTypes);
return(new GeneratedTypesContext(generatedTypes));
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(BuildExceptionMessage(generationSubjectName, ex), ex);
}
catch (NotSupportedException ex)
{
throw new NotSupportedException(BuildExceptionMessage(generationSubjectName, ex), ex);
}
}
public TypeAssemblyResult AssembleAdditionalType(
object additionalTypeID,
IParticipantState participantState,
IMutableTypeBatchCodeGenerator codeGenerator)
{
ArgumentUtility.CheckNotNull("additionalTypeID", additionalTypeID);
ArgumentUtility.CheckNotNull("participantState", participantState);
ArgumentUtility.CheckNotNull("codeGenerator", codeGenerator);
var context = new AdditionalTypeAssemblyContext(_mutableTypeFactory, _participantConfigurationID, participantState);
var additionalType = _participants.Select(p => p.GetOrCreateAdditionalType(additionalTypeID, context)).FirstOrDefault(t => t != null);
if (additionalType == null)
{
throw new NotSupportedException("No participant provided an additional type for the given identifier.");
}
var generatedTypesContext = GenerateTypesWithDiagnostics(codeGenerator, context.AdditionalTypes.Values, additionalTypeID.ToString());
context.OnGenerationCompleted(generatedTypesContext);
Type resultType;
if (additionalType is MutableType)
{
resultType = generatedTypesContext.GetGeneratedType((MutableType)additionalType);
}
else
{
resultType = additionalType;
}
return(new TypeAssemblyResult(
resultType,
context.AdditionalTypes.ToDictionary(kvp => kvp.Key, kvp => generatedTypesContext.GetGeneratedType(kvp.Value))));
}
private GeneratedTypesContext GenerateTypes(AssembledTypeID typeID, ProxyTypeAssemblyContext context, IMutableTypeBatchCodeGenerator codeGenerator)
{
// Add [AssembledType] attribute.
var attribute = new CustomAttributeDeclaration(s_assembledTypeAttributeCtor, new object[0]);
context.ProxyType.AddCustomAttribute(attribute);
// Add '__typeID' and initialization code.
_assembledTypeIdentifierProvider.AddTypeID(context.ProxyType, typeID);
// Enable complex serialization.
_complexSerializationEnabler.MakeSerializable(context.ProxyType, _participantConfigurationID, _assembledTypeIdentifierProvider, typeID);
var mutableTypes = context.AdditionalTypes.Values.Concat(new[] { context.ProxyType });
return(GenerateTypesWithDiagnostics(codeGenerator, mutableTypes, context.RequestedType.Name));
}
public TypeAssemblyResult AssembleType(AssembledTypeID typeID, IParticipantState participantState, IMutableTypeBatchCodeGenerator codeGenerator)
{
ArgumentUtility.CheckNotNull("typeID", typeID);
ArgumentUtility.CheckNotNull("participantState", participantState);
ArgumentUtility.CheckNotNull("codeGenerator", codeGenerator);
var requestedType = typeID.RequestedType;
CheckRequestedType(requestedType);
if (ShortCircuitTypeAssembly(requestedType))
{
return(new TypeAssemblyResult(requestedType));
}
var typeModificationTracker = _mutableTypeFactory.CreateProxy(requestedType, ProxyKind.AssembledType);
var context = new ProxyTypeAssemblyContext(
_mutableTypeFactory, _participantConfigurationID, participantState, requestedType, typeModificationTracker.Type);
foreach (var participant in _participants)
{
var idPart = _assembledTypeIdentifierProvider.GetPart(typeID, participant);
participant.Participate(idPart, context);
}
if (!typeModificationTracker.IsModified())
{
return(new TypeAssemblyResult(requestedType));
}
var generatedTypesContext = GenerateTypes(typeID, context, codeGenerator);
context.OnGenerationCompleted(generatedTypesContext);
return(new TypeAssemblyResult(
generatedTypesContext.GetGeneratedType(context.ProxyType),
context.AdditionalTypes.ToDictionary(kvp => kvp.Key, kvp => generatedTypesContext.GetGeneratedType(kvp.Value))));
}
