public void PerformTest()
{
using (var ad = Qi4CSTestUtils.CreateTestAppDomain("Qi4CS Mixin Visiblity Test"))
{
ad.DoCallBack(() =>
{
Action a = () =>
{
var architecture = Qi4CSArchitectureFactory.NewLayeredArchitecture();
var testPerformerLayer = architecture.GetOrCreateLayer(AbstractLayeredArchitectureInstanceTest.LAYER_NAME);
var mainAssembler = testPerformerLayer.GetOrCreateModule(AbstractLayeredArchitectureInstanceTest.MODULE_NAME).CompositeAssembler;
mainAssembler.NewPlainComposite().OfTypes(typeof(TestPerformer)).WithMixins(typeof(TestPerformerMixin));
this.Assemble(architecture, testPerformerLayer, mainAssembler);
var model = architecture.CreateModel();
model.GenerateAndSaveAssemblies(emittingInfoCreator: Qi4CSCodeGenHelper.EmittingArgumentsCallback);
var application = model.NewInstance(TestConstants.APPLICATION_NAME, TestConstants.APPLICATION_MODE, TestConstants.APPLICATION_VERSION);
application.Activate();
var performer = application.FindModule(AbstractLayeredArchitectureInstanceTest.LAYER_NAME, AbstractLayeredArchitectureInstanceTest.MODULE_NAME).StructureServices.NewPlainCompositeBuilder <TestPerformer>().Instantiate();
Assert.AreEqual(TEST_1_OK, performer.Test1());
Assert.AreEqual(TEST_2_OK, performer.Test2());
};
if (this._expectedException == null)
{
a();
}
else
{
Assert.Throws(this._expectedException, new TestDelegate(a));
}
});
}
}
public void PerformTest()
{
_domain.DoCallBack(() =>
{
var architecture = Qi4CSArchitectureFactory.NewSingletonArchitecture();
var assembler = architecture.CompositeAssembler;
assembler
.NewPlainComposite().OfTypes(typeof(MyComposite))
.WithConcerns(typeof(MyCompositeConcern)).Done()
.WithSideEffects(typeof(MyCompositeSideEffect)).Done()
.WithMixins(typeof(MyCompositeMixin));
assembler
.NewService().OfTypes(typeof(MyService));
architecture.AttributeProcessingEvent += new EventHandler <AttributeProcessingArgs>(architecture_AttributeProcessingEvent);
var model = architecture.CreateModel();
model.GenerateAndSaveAssemblies(emittingInfoCreator: Qi4CSCodeGenHelper.EmittingArgumentsCallback);
var application = model.NewInstance(TestConstants.APPLICATION_NAME, TestConstants.APPLICATION_MODE, TestConstants.APPLICATION_VERSION);
application.Activate();
try
{
var builder = application.StructureServices.NewPlainCompositeBuilder <MyComposite>();
builder.Prototype().ImmutableProperty = IMMUTABLE_PROPERTY;
var composite = builder.Instantiate();
this.TestComposite(composite);
}
finally
{
application.Passivate();
}
});
}
protected override ApplicationArchitecture <ApplicationModel <ApplicationSPI> > CreateApplicationArchitecture()
{
var architecture = Qi4CSArchitectureFactory.NewLayeredArchitecture();
var layer1 = architecture.GetOrCreateLayer(LAYER_1);
layer1.UseLayers(layer1);
return(architecture);
}
protected override Core.Bootstrap.Assembling.ApplicationArchitecture <SingletonApplicationModel> BuildArchitecture()
{
var architecture = Qi4CSArchitectureFactory.NewSingletonArchitecture();
architecture.CompositeAssembler
.NewPlainComposite()
.OfTypes(typeof(TestComposite))
.WithMixins(typeof(TestCompositeMixin));
return(architecture);
}
// Need to implement this method that will take care of creating Qi4CS architecture
// and setting it up.
protected override ApplicationArchitecture <SingletonApplicationModel> BuildArchitecture()
{
var architecture = Qi4CSArchitectureFactory.NewSingletonArchitecture();
architecture.CompositeAssembler
.NewPlainComposite()
.OfTypes(typeof(MyDomainFunctionality))
.WithMixins(typeof(MyDomainFunctionalityMixin));
return(architecture);
}
private void DummyMethod()
{
#region PrivateCompositesCode2
var architecture = Qi4CSArchitectureFactory.NewSingletonArchitecture();
architecture.CompositeAssembler
.NewPlainComposite()
.OfTypes(typeof(MyComposite))
.WithMixins(typeof(MyCompositeMixin));
// MyCompositeState is not included in the .OfTypes method parameters.
// Therefore, it will become a private composite type.
#endregion
}
protected override ApplicationArchitecture <ApplicationModel <ApplicationSPI> > CreateApplicationArchitecture()
{
var architecture = Qi4CSArchitectureFactory.NewLayeredArchitecture();
var layer = architecture.GetOrCreateLayer(LAYER_NAME);
var module1 = layer.GetOrCreateModule(MODULE_1_NAME);
module1.CompositeAssembler.NewLayeredService().VisibleIn(Visibility.MODULE).OfTypes(typeof(ServiceComposite));
var module2 = layer.GetOrCreateModule(MODULE_2_NAME);
module2.CompositeAssembler.NewLayeredPlainComposite().OfTypes(typeof(TransientComposite)).WithMixins(typeof(TransientMixin));
return(architecture);
}
protected override ApplicationArchitecture <ApplicationModel <ApplicationSPI> > CreateApplicationArchitecture()
{
var architecture = Qi4CSArchitectureFactory.NewSingletonArchitecture();
Type compositeType = null;
Type[] mixins = null, concerns = null, sideEffects = null;
this.SetupApplicationArchitecture(ref compositeType, ref mixins, ref concerns, ref sideEffects);
var decl = architecture.CompositeAssembler.NewPlainComposite().OfTypes(compositeType);
if (mixins != null)
{
decl.WithMixins(mixins);
}
if (concerns != null)
{
decl.WithConcerns(concerns);
}
if (sideEffects != null)
{
decl.WithSideEffects(sideEffects);
}
return(architecture);
}
protected override SingletonArchitecture CreateArchitecture()
{
return(Qi4CSArchitectureFactory.NewSingletonArchitecture());
}
public void SetUp()
{
_appDomain = Qi4CSTestUtils.CreateTestAppDomain("Qi4CS Configuration test.");
_appDomain.DoCallBack(() =>
{
// Typical usecase scenario, first create architecture
var architecture = Qi4CSArchitectureFactory.NewLayeredArchitecture();
// Add layer for all configuration composites
var configLayer = architecture.GetOrCreateLayer("ConfigLayer");
// Add a module for all configuration composites
var configModule = configLayer.GetOrCreateModule("ConfigModule");
// Assembler for configuration module
var assembler = configModule.CompositeAssembler;
var customSerializers = new List <XMLConfigurationSerializerHelper>();
// IPEndPoint is not a Qi4CS composite - add custom (de)serialization support for it
customSerializers.Add(new XMLConfigurationSerializerWithCallbacks(
(obj, type) => typeof(IPEndPoint).Equals(type),
(obj, type, parent) => parent.Add(new XElement("Address", ((IPEndPoint)obj).Address.ToString()), new XElement("Port", ((IPEndPoint)obj).Port.ToString())),
(element, type) => typeof(IPEndPoint).Equals(type),
(element, type) =>
{
var addressString = element.Element("Address").Value;
IPAddress address;
if (!IPAddress.TryParse(addressString, out address))
{
address = Dns.GetHostEntry(addressString).AddressList[0];
}
return(new IPEndPoint(address, Int32.Parse(element.Element("Port").Value)));
}
));
// Add serialization composite
assembler.AddXMLSerializationSupport(null, customSerializers);
// Add composites part of the configuration
assembler
.NewPlainComposite()
.OfTypes(typeof(DatabaseConfiguration));
assembler
.NewLayeredPlainComposite()
.VisibleIn(Visibility.MODULE)
.OfTypes(typeof(DatabaseSetup));
// Add support for configuration service and instances
assembler.AddSupportForAllConfigurationInstancesAndManager()
.WithDefaultsFor(typeof(DatabaseConfiguration)) // Set default values for DatabaseConfiguration
.SerializedByXML() // Make DatabaseConfiguration (de)serialization process use XMLConfigurationSerializer
.LocatedInXMLDocument(CONFIG_FILE_FULL_PATH); // Default location for DatabaseConfiguration
// Add the test composite
var testLayer = architecture.GetOrCreateLayer("TestLayer");
var testModule = testLayer.GetOrCreateModule("TestModule");
assembler = testModule.CompositeAssembler;
assembler.NewLayeredPlainComposite().OfTypes(typeof(CompositeUsingConfiguration)).WithMixins(typeof(CompositeUsingConfigurationMixin));
testLayer.UseLayers(configLayer);
var model = architecture.CreateModel();
model.GenerateAndSaveAssemblies(emittingInfoCreator: Qi4CSCodeGenHelper.EmittingArgumentsCallback);
var application = model.NewInstance(TestConstants.APPLICATION_NAME, TestConstants.APPLICATION_MODE, TestConstants.APPLICATION_VERSION);
_ssp = assembler.GetStructureServiceProvider(application);
application.Activate();
});
//var configSSP = configModule.CompositeAssembler.GetStructureServiceProvider( application );
//var suckaObjBuilder = configSSP.NewPlainCompositeBuilder<DatabaseConfiguration>();
//suckaObjBuilder.Prototype().DatabaseSetups = new Dictionary<String, DatabaseSetup>();
//var localConnBuilder = configSSP.NewPlainCompositeBuilder<DatabaseSetup>();
//localConnBuilder.Prototype().DatabaseName = "SomeDB";
//localConnBuilder.Prototype().DatabaseConnectionInformation = new IPEndPoint( IPAddress.Loopback, 1000 );
//suckaObjBuilder.Prototype().DatabaseSetups.Add( "Local", localConnBuilder.Instantiate() );
//var sucka = new XElement( "DatabaseConfiguration" );
//configSSP.FindService<XMLSerializationService>().Service.Serialize( suckaObjBuilder.Instantiate(), sucka );
}
protected override LayeredArchitecture CreateArchitecture()
{
return(Qi4CSArchitectureFactory.NewLayeredArchitecture());
}
