private void OverrideGetObjectData(MutableType proxyType, Tuple <string, FieldInfo>[] serializedFieldMapping)
{
try
{
proxyType
.GetOrAddImplementation(s_getObjectDataMethod)
.SetBody(
ctx => Expression.Block(
typeof(void),
new[] { ctx.PreviousBody }.Concat(BuildFieldSerializationExpressions(ctx.This, ctx.Parameters[0], serializedFieldMapping))));
}
catch (NotSupportedException)
{
// Overriding and re-implementation failed because the base implementation is not accessible from the proxy.
// Do nothing here; error reporting code will be generated in the ProxySerializationEnabler.
// Add an explicit re-implementation that throws exception (instead of simply throwing an exception here).
// Reasoning: Users often cannot influence the requested type and do not care about any serialization problem.
proxyType.AddInterface(typeof(ISerializable), throwIfAlreadyImplemented: false);
var message = "The requested type implements ISerializable but GetObjectData is not accessible from the proxy. "
+ "Make sure that GetObjectData is implemented implicitly (not explicitly).";
proxyType.AddExplicitOverride(
s_getObjectDataMethod,
ctx => Expression.Throw(Expression.New(s_serializationExceptionConstructor, Expression.Constant(message))));
}
}
private void OverrideOnDeserialization(MutableType proxyType, MethodInfo initializationMethod)
{
try
{
proxyType.GetOrAddImplementation(s_onDeserializationMethod)
.SetBody(
ctx => Expression.Block(
typeof(void),
ctx.PreviousBody,
CallInitializationMethod(ctx.This, initializationMethod)));
}
catch (NotSupportedException)
{
// Overriding and re-implementation failed because the base implementation is not accessible from the proxy.
// Add an explicit re-implementation that throws exception (instead of simply throwing an exception here).
// Reasoning: Users often cannot influence the requested type and do not care about any serialization problem.
proxyType.AddInterface(typeof(IDeserializationCallback), throwIfAlreadyImplemented: false);
var message = "The requested type implements IDeserializationCallback but OnDeserialization is not accessible from the proxy. "
+ "Make sure that OnDeserialization is implemented implicitly (not explicitly).";
proxyType.AddExplicitOverride(
s_onDeserializationMethod,
ctx => Expression.Throw(Expression.New(s_serializationExceptionConstructor, Expression.Constant(message))));
}
}
public void AddInterfaces(IEnumerable <Type> interfacesToImplement)
{
ArgumentUtility.CheckNotNull("interfacesToImplement", interfacesToImplement);
foreach (var ifc in interfacesToImplement)
{
_concreteTarget.AddInterface(ifc);
}
}
public void MakeSerializable(
MutableType proxyType,
string participantConfigurationID,
IAssembledTypeIdentifierProvider assembledTypeIdentifierProvider,
AssembledTypeID typeID)
{
ArgumentUtility.CheckNotNull("proxyType", proxyType);
ArgumentUtility.CheckNotNullOrEmpty("participantConfigurationID", participantConfigurationID);
ArgumentUtility.CheckNotNull("assembledTypeIdentifierProvider", assembledTypeIdentifierProvider);
if (!proxyType.IsTypePipeSerializable())
{
return;
}
var assembledTypeIDData = assembledTypeIdentifierProvider.GetAssembledTypeIDDataExpression(typeID);
if (typeof(ISerializable).IsTypePipeAssignableFrom(proxyType))
{
// If the mutable type already implements ISerializable, we only need to extend the implementation to include the metadata required for
// deserialization. Existing fields will be serialized by the base ISerialization implementation. Added fields will be serialized by
// the TypePipe (ProxySerializationEnabler).
try
{
proxyType
.GetOrAddImplementation(s_getObjectDataMethod)
.SetBody(
ctx => Expression.Block(
ctx.PreviousBody,
CreateMetaDataSerializationExpression(
ctx.Parameters[0], typeof(ObjectWithDeserializationConstructorProxy), participantConfigurationID, assembledTypeIDData)));
}
catch (NotSupportedException)
{
// Overriding and re-implementation failed because the base implementation of GetObjectData is not accessible from the proxy.
// Do nothing here; error reporting code will be generated in the ProxySerializationEnabler.
// Reasoning: Users often cannot influence the requested type and do not care about any serialization problem.
}
}
else
{
// If the mutable type does not implement ISerializable, we need to add the interface and then also serialize all the fields on the object.
// We cannot add a deserialization constructor because there is no base constructor that we could call. Therefore, ProxySerializationEnabler
// cannot take care of serializing the added fields, and we thus have to serialize both existing and added fields ourselves via
// ReflectionSerializationHelper.AddFieldValues.
proxyType.AddInterface(typeof(ISerializable));
proxyType.AddExplicitOverride(
s_getObjectDataMethod,
ctx => Expression.Block(
CreateMetaDataSerializationExpression(
ctx.Parameters[0], typeof(ObjectWithoutDeserializationConstructorProxy), participantConfigurationID, assembledTypeIDData),
Expression.Call(s_addFieldValuesMethod, ctx.Parameters[0], ctx.This)));
}
}
public MutableMethodInfo GetOrCreateImplementation(MutableType declaringType, MethodInfo interfaceMethod, out bool isNewlyCreated)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNull("interfaceMethod", interfaceMethod);
Assertion.IsNotNull(interfaceMethod.DeclaringType);
if (!interfaceMethod.DeclaringType.IsInterface)
{
throw new ArgumentException("The specified method is not an interface method.", "interfaceMethod");
}
CheckIsNotMethodInstantiation(interfaceMethod, "interfaceMethod");
// ReSharper disable PossibleUnintendedReferenceComparison
if (!interfaceMethod.DeclaringType.IsTypePipeAssignableFrom(declaringType))
// ReSharper restore PossibleUnintendedReferenceComparison
{
Assertion.IsNotNull(interfaceMethod.DeclaringType);
var message = string.Format(
"Method is declared by an interface that is not implemented by the proxy: '{0}'.", interfaceMethod.DeclaringType.Name);
throw new ArgumentException(message, "interfaceMethod");
}
var baseImplementation = GetOrCreateImplementationMethod(declaringType, interfaceMethod, out isNewlyCreated);
if (baseImplementation is MutableMethodInfo)
{
return((MutableMethodInfo)baseImplementation);
}
Assertion.IsTrue(baseImplementation.IsVirtual, "It is not possible to get an interface implementation that is not virtual (in verifiable code).");
// Re-implement if final.
if (baseImplementation.IsFinal)
{
if (!SubclassFilterUtility.IsVisibleFromSubclass(baseImplementation))
{
Assertion.IsNotNull(baseImplementation.DeclaringType);
var message = string.Format(
"Cannot re-implement interface method '{0}' because its base implementation on '{1}' is not accessible.",
interfaceMethod.Name,
baseImplementation.DeclaringType.Name);
throw new NotSupportedException(message);
}
declaringType.AddInterface(interfaceMethod.DeclaringType, throwIfAlreadyImplemented: false);
var attributes = interfaceMethod.Attributes.Unset(MethodAttributes.Abstract);
Func <MethodBodyCreationContext, Expression> bodyProvider = ctx => ctx.DelegateToBase(baseImplementation);
isNewlyCreated = true;
return(CreateMethod(declaringType, interfaceMethod, interfaceMethod.Name, attributes, bodyProvider));
}
return(GetOrCreateOverride(declaringType, baseImplementation, out isNewlyCreated));
}
private void AddRequiredInterfaces(MutableType nextCallProxy, TargetClassDefinition targetClassDefinition)
{
var interfaces = EnumerableUtility
.Singleton(typeof(IGeneratedNextCallProxyType))
.Concat(targetClassDefinition.RequiredNextCallTypes.Select(requiredType => requiredType.Type));
foreach (var ifc in interfaces)
{
nextCallProxy.AddInterface(ifc);
}
}
public void DefineTypeFacets()
{
var typeInitializer = _mutableType.AddTypeInitializer(ctx => Expression.Empty());
var instanceInitialization = ExpressionTreeObjectMother.GetSomeExpression();
_mutableType.AddInitialization(ctx => instanceInitialization);
var customAttribute = CustomAttributeDeclarationObjectMother.Create();
_mutableType.AddCustomAttribute(customAttribute);
var @interface = typeof(IDisposable);
_mutableType.AddInterface(@interface);
var field = _mutableType.AddField();
var constructor = _mutableType.AddConstructor();
var method = _mutableType.AddMethod();
var property = _mutableType.AddProperty();
var event_ = _mutableType.AddEvent();
using (_mockRepository.Ordered())
{
var context = PopulateContext(_generator, 2);
_typeBuilderMock.Expect(mock => mock.SetParent(_mutableType.BaseType));
_memberEmitterMock.Expect(mock => mock.AddConstructor(context, typeInitializer));
_initializationBuilderMock.Expect(mock => mock.CreateInitializationMembers(_mutableType)).Return(_fakeInitializationMembers);
_proxySerializationEnablerMock.Expect(mock => mock.MakeSerializable(_mutableType, _fakeInitializationMethod));
_typeBuilderMock.Expect(mock => mock.SetCustomAttribute(customAttribute));
_typeBuilderMock.Expect(mock => mock.AddInterfaceImplementation(@interface));
_memberEmitterMock.Expect(mock => mock.AddField(context, field));
_initializationBuilderMock.Expect(
mock => mock.WireConstructorWithInitialization(constructor, _fakeInitializationMembers, _proxySerializationEnablerMock));
_memberEmitterMock.Expect(mock => mock.AddConstructor(context, constructor));
_memberEmitterMock.Expect(mock => mock.AddMethod(context, method));
SetupExpectationsForAccessors(_memberEmitterMock, _mutableType.AddedMethods.Except(new[] { method }));
_memberEmitterMock.Expect(mock => mock.AddProperty(context, property));
_memberEmitterMock.Expect(mock => mock.AddEvent(context, event_));
}
_mockRepository.ReplayAll();
_generator.DefineTypeFacets();
_mockRepository.VerifyAll();
}
public Tuple <FieldInfo, MethodInfo> CreateInitializationMembers(MutableType mutableType)
{
ArgumentUtility.CheckNotNull("mutableType", mutableType);
var initialization = mutableType.Initialization;
if (initialization.Expressions.Count == 0)
{
return(null);
}
mutableType.AddInterface(typeof(IInitializableObject));
var counter = mutableType.AddField("<tp>_ctorRunCounter", FieldAttributes.Private, typeof(int));
var nonSerializedCtor = MemberInfoFromExpressionUtility.GetConstructor(() => new NonSerializedAttribute());
counter.AddCustomAttribute(new CustomAttributeDeclaration(nonSerializedCtor, new object[0]));
var initializationMethod = mutableType.AddExplicitOverride(s_interfaceMethod, ctx => CreateInitializationBody(ctx, initialization));
return(Tuple.Create <FieldInfo, MethodInfo> (counter, initializationMethod));
}
public static void AddInterface(this MutableType mutableType, Type interfaceType = null)
{
interfaceType = interfaceType ?? ReflectionObjectMother.GetSomeInterfaceType();
mutableType.AddInterface(interfaceType);
}
private void ExplicitlyImplementOnDeserialization(MutableType proxyType, MethodInfo initializationMethod)
{
proxyType.AddInterface(typeof(IDeserializationCallback));
proxyType.AddExplicitOverride(s_onDeserializationMethod, ctx => CallInitializationMethod(ctx.This, initializationMethod));
}
public void AddInterfaces()
{
_type.AddInterface(typeof(ISerializable));
_type.AddInterface(typeof(IGeneratedMixinType));
}