public void SetUp()
{
_innerMock = MockRepository.GenerateStrictMock <IFieldBuilder> ();
_operandProvider = MockRepository.GenerateStrictMock <IEmittableOperandProvider> ();
_decorator = new FieldBuilderDecorator(_innerMock, _operandProvider);
}
/// <summary>
/// Adds a constructor to the mixin type.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> use to construct the type.</param>
/// <param name="mixinType">The mixin <see cref="Type"/> being created.</param>
/// <param name="baseTypesField">The <see cref="FieldBuilder"/> which will hold the instances of the base types.</param>
/// <param name="serviceProviderField">The <see cref="FieldBuilder"/> which will hold the instance of the dependency injection resolver.</param>
private void EmitConstructor(
ITypeBuilder typeBuilder,
Type mixinType,
IFieldBuilder baseTypesField,
IFieldBuilder serviceProviderField)
{
var constructorBuilder = typeBuilder
.NewConstructor()
.Public()
.HideBySig()
.SpecialName()
.RTSpecialName()
.CallingConvention(CallingConventions.HasThis)
.Param <object[]>("instances")
.Param <IServiceProvider>("serviceProvider");
constructorBuilder
.Body()
.LdArg0()
.LdArg1()
.StFld(baseTypesField)
.LdArg0()
.LdArg2()
.StFld(serviceProviderField)
.Ret();
}
/// <summary>
/// Adds a constructor to the mixin type.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> use to construct the type.</param>
/// <param name="baseType">The base <see cref="Type"/> being ducked.</param>
/// <param name="baseTypeField">The <see cref="FieldBuilder"/> which will hold the instances of the base types.</param>
/// <param name="serviceProviderField">The <see cref="FieldBuilder"/> which will hold the instance of the dependency injection resolver.</param>
private void AddConstructor(
ITypeBuilder typeBuilder,
Type baseType,
IFieldBuilder baseTypeField,
IFieldBuilder serviceProviderField)
{
// Build Constructor.
var constructorBuilder = typeBuilder
.NewConstructor()
.Public()
.HideBySig()
.SpecialName()
.RTSpecialName()
.CallingConvention(CallingConventions.HasThis)
.Param(baseType, "target")
.Param <IServiceProvider>("serviceProvider");
constructorBuilder
.Body()
.LdArg0()
.Call(baseType.GetConstructor(new Type[0]))
.LdArg0()
.LdArg1()
.StFld(baseTypeField)
.LdArg0()
.LdArg2()
.StFld(serviceProviderField)
.Ret();
}
public abstract IEnumerable <EntityField> BuildEntityFields(
IFieldBuilder fieldBuilder,
EntityDefinition entityDefinition,
TypeModel typeModel,
IEnumerable <IField> relativeParentFields = null,
IEnumerable <IField> fullParentFields = null,
IQueryReference source = null
);
/// <summary>
/// Initializes a new instance of the <see cref="TypeFactoryContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseType">The base type being built on.</param>
/// <param name="serviceProvider">The current dependency injection scope</param>
/// <param name="baseObjectField">The <see cref="FieldBuilder"/> that holds the base type instance.</param>
/// <param name="serviceProviderField">The <see cref="FieldBuilder"/> that holds the <see cref="IServiceProvider"/> instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the types constructor.</param>
public TypeFactoryContext(
ITypeBuilder typeBuilder,
Type newType,
Type baseType,
IServiceProvider serviceProvider,
IFieldBuilder baseObjectField,
IFieldBuilder serviceProviderField,
IConstructorBuilder ctorBuilder = null)
: this(typeBuilder, newType, new Type[] { baseType }, serviceProvider, baseObjectField, serviceProviderField, ctorBuilder)
{
}
public FiveOneTwoGameCreator(int _gameSize)
{
if (_gameSize <= 3)
{
throw new ArgumentException(nameof(_gameSize) + " should be more or equal then 3 ");
}
gameSize = _gameSize;
gameBuilder = new FiveOneTwoGameBuilder();
fieldBuilder = new FiveOneTwoFieldBuilder(gameSize);
}
public IField StartApp()
{
Player p = new Player("azazalo");
IRobotProducer rp = new RobotProducer();
Robot MyRobot = rp.PickRobot(p.PlayerId);
IFieldBuilder b = new FieldBuilder();
this.builder = b;
var field = builder.CreateField(10, 10, MyRobot);
return(field);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyBuilderContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseTypes">The base types being built on.</param>
/// <param name="baseObjectField">The <see cref="FieldBuilder"/> that holds the base type instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the types constructor.</param>
public ProxyBuilderContext(
ITypeBuilder typeBuilder,
Type newType,
Type[] baseTypes,
IFieldBuilder baseObjectField,
IConstructorBuilder ctorBuilder = null)
{
this.TypeBuilder = typeBuilder;
this.NewType = newType;
this.BaseTypes = baseTypes;
this.BaseObjectField = baseObjectField;
this.ConstructorBuilder = ctorBuilder;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyBuilderContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseType">The base type being built on.</param>
/// <param name="baseObjectField">The <see cref="FieldBuilder"/> that holds the base type instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the types constructor.</param>
public ProxyBuilderContext(
ITypeBuilder typeBuilder,
Type newType,
Type baseType,
IFieldBuilder baseObjectField,
IConstructorBuilder ctorBuilder = null)
: this(typeBuilder,
newType,
new Type[] { baseType },
baseObjectField,
ctorBuilder)
{
}
/// <summary>
/// Implements the <see cref="IMixinObject"/> interface on the mixin type.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> use to construct the type.</param>
/// <param name="baseTypeField">The <see cref="FieldBuilder"/> which will hold the instances of the types that make up the mixin.</param>
private void EmitMixinObjectInterface(
ITypeBuilder typeBuilder,
IFieldBuilder baseTypeField)
{
var propertyMixinObjects = typeBuilder
.NewProperty <object[]>("MixinObjects")
.Getter(m => m
.Public()
.Virtual()
.HideBySig()
.NewSlot()
.CallingConvention(CallingConventions.HasThis)
.Body(il => il
.LdArg0()
.LdFld(baseTypeField)
.Ret()));
}
public GamePlayProcessor(IGame _game, IFieldBuilder _fieldBuilder, IGameDataProvider _gameDataProvider)
{
if (_game == null)
{
throw new ArgumentNullException(nameof(_game) + " should be passed");
}
if (_gameDataProvider == null)
{
throw new ArgumentNullException(nameof(_gameDataProvider) + "should be passed");
}
if (_fieldBuilder == null)
{
throw new ArgumentNullException(nameof(_fieldBuilder) + "should be passed");
}
game = _game;
}
/// <summary>
/// Implements the <see cref="IDuckTypedObject"/> interface on the duck type.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> use to construct the type.</param>
/// <param name="baseTypeField">The <see cref="FieldBuilder"/> which will hold the instance of the type being duck typed.</param>
private void ImplementDuckTypedObjectInterface(
ITypeBuilder typeBuilder,
IFieldBuilder baseTypeField)
{
var propertyAdaptedObject = typeBuilder
.NewProperty <object>("DuckTypedObject")
.Getter(m => m
.Public()
.Virtual()
.HideBySig()
.NewSlot()
.CallingConvention(CallingConventions.HasThis)
.Body(il => il
.LdArg0()
.LdFld(baseTypeField)
.Ret()));
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeFactoryContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="ITypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseTypes">The base types being built on.</param>
/// <param name="serviceProvider">The current dependency injection scope</param>
/// <param name="baseObjectField">The <see cref="IFieldBuilder"/> that holds the base type instance.</param>
/// <param name="serviceProviderField">The <see cref="IFieldBuilder"/> that holds the <see cref="IServiceProvider"/> instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the Itypes constructor.</param>
public TypeFactoryContext(
ITypeBuilder typeBuilder,
Type newType,
Type[] baseTypes,
IServiceProvider serviceProvider,
IFieldBuilder baseObjectField,
IFieldBuilder serviceProviderField,
IConstructorBuilder ctorBuilder = null)
{
this.TypeBuilder = typeBuilder;
this.NewType = newType;
this.BaseTypes = baseTypes;
this.ServiceProvider = serviceProvider;
this.BaseObjectField = baseObjectField;
this.ServiceProviderField = serviceProviderField;
this.ConstructorBuilder = ctorBuilder;
}
/// <summary>
/// Adds a constructor to the adapter type.
/// </summary>
/// <param name="typeBuilder">The <see cref="ITypeBuilder"/> use to construct the type.</param>
/// <param name="controllerServiceType">The <see cref="Type"/> controllers service implementation.</param>
/// <param name="controllerServiceTypeField">The <see cref="IFieldBuilder"/> which will hold the instance of the controllers service implementation type.</param>
/// <returns>The <see cref="ConstructorBuilder"/> used to build the constructor.</returns>
private IConstructorBuilder AddConstructor(
ITypeBuilder typeBuilder,
Type controllerServiceType,
IFieldBuilder controllerServiceTypeField)
{
var constructorBuilder = typeBuilder
.NewConstructor()
.Public()
.HideBySig()
.SpecialName()
.RTSpecialName()
.CallingConvention(CallingConventions.HasThis)
.Param(controllerServiceType, "controllerService");
constructorBuilder
.Body()
.LdArg0()
.LdArg1()
.StFld(controllerServiceTypeField)
.Ret();
return(constructorBuilder);
}
/// <summary>
/// Specifies that the field has marshaling information.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder HasFieldMarshal(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.HasFieldMarshal;
return(builder);
}
/// <summary>
/// Specifies that the field has a default value.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder HasDefault(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.HasDefault;
return(builder);
}
public static FieldProperty New(string name, Type type, IFieldBuilder builder)
{
return(new FieldProperty {
Name = name, Type = type, Builder = builder
});
}
/// <summary>
/// Loads a fields token.
/// </summary>
/// <param name="emitter">An <see cref="IEmitter"/> instance.</param>
/// <param name="field">The field.</param>
/// <returns>The <see cref="IEmitter"/> instance.</returns>
public static IEmitter LdToken(this IEmitter emitter, IFieldBuilder field)
{
return(emitter
.LdToken(field.Define()));
}
/// <summary>
/// Emits the IL to load the address of a static field onto the evaluation stack.
/// </summary>
/// <param name="emitter">An <see cref="IEmitter"/> instance.</param>
/// <param name="field">A <see cref="IFieldBuilder"/>.</param>
/// <returns>The <see cref="IEmitter"/> instance.</returns>
public static IEmitter LdsFlda(this IEmitter emitter, IFieldBuilder field)
{
emitter.Emit(OpCodes.Ldsflda, field);
return(emitter);
}
/// <summary>
/// Specifies that the field is accessible by subtypes anywhere, as well as throughout
/// this assembly.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder FamORAssem(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.FamORAssem;
return(builder);
}
/// <summary>
/// Specifies that the common language runtime (metadata internal APIs) should check
/// the name encoding.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder RTSpecialName(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.RTSpecialName;
return(builder);
}
/// <summary>
/// Emits IL to store the value at the top of the evaluation stack in a static field.
/// </summary>
/// <param name="emitter">An <see cref="IEmitter"/>.</param>
/// <param name="field">A field</param>
/// <returns>The <see cref="IEmitter"/>.</returns>
public static IEmitter StSFld(this IEmitter emitter, IFieldBuilder field)
{
return(emitter.Emit(OpCodes.Stsfld, field));
}
/// <summary>
/// Specifies that the field has a relative virtual address (RVA). The RVA is the
/// location of the method body in the current image, as an address relative to the
/// start of the image file in which it is located.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder HasFieldRVA(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.HasFieldRVA;
return(builder);
}
/// <summary>
/// Specifies that the field is initialized only, and can be set only in the body
/// of a constructor.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder InitOnly(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.InitOnly;
return(builder);
}
/// <summary>
/// Specifies that the field represents the defined type, or else it is per-instance.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder Static(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.Static;
return(builder);
}
/// <summary>
/// Specifies that the field is accessible throughout the assembly.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder Assembly(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.Assembly;
return(builder);
}
public FieldBuilderDecorator(IFieldBuilder fieldBuilder, IEmittableOperandProvider emittableOperandProvider)
: base(fieldBuilder, emittableOperandProvider)
{
_fieldBuilder = fieldBuilder;
}
/// <summary>
/// Specifies that the field is accessible only by type and subtypes.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder Family(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.Family;
return(builder);
}
/// <inheritdoc/>
public IEmitter Emit(OpCode opcode, IFieldBuilder field)
{
this.ilGen.Emit(opcode, field.Define());
return(this);
}
/// <summary>
/// Specifies that the field is accessible only by the parent type.
/// </summary>
/// <param name="builder">A <see cref="IFieldBuilder"/> instance.</param>
/// <returns>The <see cref="IFieldBuilder"/> instance.</returns>
public static IFieldBuilder Private(this IFieldBuilder builder)
{
builder.FieldAttributes |= FieldAttributes.Private;
return(builder);
}
