public void SetUp()
{
_mutableTypeFactoryMock = MockRepository.GenerateStrictMock <IMutableTypeFactory>();
_participantStateMock = MockRepository.GenerateStrictMock <IParticipantState>();
_participantConfigurationID = "participant configuration ID";
_context = new TestableTypeAssemblyContextBase(_mutableTypeFactoryMock, _participantConfigurationID, _participantStateMock);
}
public LoadedTypesContext(IEnumerable <LoadedProxy> proxyTypes, IEnumerable <Type> additionalTypes, IParticipantState participantState)
{
ArgumentUtility.CheckNotNull("proxyTypes", proxyTypes);
ArgumentUtility.CheckNotNull("additionalTypes", additionalTypes);
ArgumentUtility.CheckNotNull("participantState", participantState);
_proxyTypes = proxyTypes.ToList().AsReadOnly();
_additionalTypes = additionalTypes.ToList().AsReadOnly();
_participantState = participantState;
}
public void SetUp()
{
_mutableTypeFactoryMock = MockRepository.GenerateStrictMock <IMutableTypeFactory>();
_complexSerializationEnablerMock = MockRepository.GenerateStrictMock <IComplexSerializationEnabler>();
_participantStateMock = MockRepository.GenerateStrictMock <IParticipantState>();
_requestedType = typeof(RequestedType);
_typeID = AssembledTypeIDObjectMother.Create(_requestedType);
_assembledType = typeof(AssembledType);
}
protected TypeAssemblyContextBase(IMutableTypeFactory mutableTypeFactory, string participantConfigurationID, IParticipantState participantState)
{
ArgumentUtility.CheckNotNull("mutableTypeFactory", mutableTypeFactory);
ArgumentUtility.CheckNotNullOrEmpty("participantConfigurationID", participantConfigurationID);
ArgumentUtility.CheckNotNull("participantState", participantState);
_mutableTypeFactory = mutableTypeFactory;
_participantConfigurationID = participantConfigurationID;
_participantState = participantState;
}
public static TypeAssemblyContextBase Create(
IMutableTypeFactory mutableTypeFactory = null,
string participantConfigurationID = "participant configuration ID",
IParticipantState state = null)
{
mutableTypeFactory = mutableTypeFactory ?? new MutableTypeFactory();
state = state ?? new ParticipantState();
return(new TestableTypeAssemblyContextBase(mutableTypeFactory, participantConfigurationID, state));
}
public static ProxyTypeAssemblyContext Create(
Type requestedType = null,
MutableType proxyType = null,
IMutableTypeFactory mutableTypeFactory = null,
string participantConfigurationID = "participant configuration ID",
IParticipantState state = null)
{
requestedType = requestedType ?? typeof(UnspecifiedRequestedType);
proxyType = proxyType ?? MutableTypeObjectMother.Create(requestedType);
mutableTypeFactory = mutableTypeFactory ?? new MutableTypeFactory();
state = state ?? new ParticipantState();
return(new ProxyTypeAssemblyContext(mutableTypeFactory, participantConfigurationID, state, requestedType, proxyType));
}
private IDictionary <ConcreteMixinTypeIdentifier, ConcreteMixinType> GetOrCreateConcreteMixinTypeCache(
IParticipantState participantState)
{
const string key = "ConcreteMixinTypes";
var concreteMixinTypeCache = (Dictionary <ConcreteMixinTypeIdentifier, ConcreteMixinType>)participantState.GetState(key);
if (concreteMixinTypeCache == null)
{
concreteMixinTypeCache = new Dictionary <ConcreteMixinTypeIdentifier, ConcreteMixinType>();
participantState.AddState(key, concreteMixinTypeCache);
}
return(concreteMixinTypeCache);
}
public ProxyTypeAssemblyContext(
IMutableTypeFactory mutableTypeFactory,
string participantConfigurationID,
IParticipantState participantState,
Type requestedType,
MutableType proxyType)
: base(mutableTypeFactory, participantConfigurationID, participantState)
{
ArgumentUtility.CheckNotNull("requestedType", requestedType);
ArgumentUtility.CheckNotNull("proxyType", proxyType);
_requestedType = requestedType;
_proxyType = proxyType;
}
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))));
}
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))));
}
public TestableTypeAssemblyContextBase(
IMutableTypeFactory mutableTypeFactory, string participantConfigurationID, IParticipantState participantState)
: base(mutableTypeFactory, participantConfigurationID, participantState)
{
}
public static LoadedTypesContext Create(
IEnumerable <LoadedProxy> proxyTypes = null, IEnumerable <Type> additionalTypes = null, IParticipantState state = null)
{
proxyTypes = proxyTypes ?? new LoadedProxy[0];
additionalTypes = additionalTypes ?? Type.EmptyTypes;
state = state ?? new ParticipantState();
return(new LoadedTypesContext(proxyTypes, additionalTypes, state));
}
