private void Dummy2(StructureServiceProvider ssp)
{
#region FunctionAggregatorDeclarationCode3
// Assume 'ssp' is variable of type Qi4CS.Core.API.Structures.StructureServiceProvider
var service = ssp.FindService <MyFunctionality>().GetService(); // Get the reference to service composite
var typeStr = service.GetStringFor(typeof(Object)); // 'typeStr' now is "System.Object_MySuffix"
var strStr = service.GetStringFor("MyTestString"); // 'strStr' now is "MyTestString_MyOtherSuffix"
#endregion
}
public static void RunCompositeCreationPerformanceTest(StructureServiceProvider ssp)
{
Int64 t0 = TestCreationPerformanceInLoop(LOOPS, () => new AnyObject(), "Minimum C# Object creation time", "object");
Int64 t1 = TestCreationPerformanceInLoop(LOOPS, () => ssp.NewPlainCompositeBuilder <AnyComposite>().Instantiate(), "Transient builder creation time", "composite");
//Int64 t2 = TestCreationPerformanceInLoop( LOOPS, () => ssp.NewValueBuilder<AnyValue>().Instantiate(), "Value builder creation time", "composite" );
Int64 t3 = TestCreationPerformanceInLoop(LOOPS, () => ssp.NewPlainCompositeBuilder <AnyObject>().Instantiate(), "Object builder creation time", "Qi4CS object");
Console.WriteLine("Transient builder: " + (t1 / t0) + "x");
//Console.WriteLine( "Value builder: " + ( t2 / t0 ) + "x" );
Console.WriteLine("Object builder: " + (t3 / t0) + "x");
}
public virtual void SetUp()
{
_appDomain = Qi4CSTestUtils.CreateTestAppDomain("Qi4CS Instance Test");
_appDomain.DoCallBack(() =>
{
ArchitectureType architecture = this.CreateArchitecture();
this.SetUpArchitecture(architecture);
var ass = ReflectionHelper.QI4CS_ASSEMBLY;
_model = this.CreateModel(architecture);
_model.GenerateAndSaveAssemblies(emittingInfoCreator: Qi4CSCodeGenHelper.EmittingArgumentsCallback);
_application = _model.NewInstance(TestConstants.APPLICATION_NAME, TestConstants.APPLICATION_MODE, TestConstants.APPLICATION_VERSION);
_structureServices = this.GetStructureProvider(_application);
_application.Activate();
});
}
public virtual void TearDown()
{
try
{
_appDomain.DoCallBack(() =>
{
if (_application != null)
{
_application.Passivate();
}
_model = null;
_structureServices = null;
});
}
finally
{
_appDomain.Dispose();
_appDomain = null;
}
}
public static void RunInvocationPerformanceTest(StructureServiceProvider ssp)
{
TestBase manualSimple = new TestMixin();
TestBase manualTypedConcernMixin = new TestMixin();
TestBase manualTypedConcernObj = new TestTypedConcern(manualTypedConcernMixin);
TestBase manualGenericConcernMixin = new TestMixin();
TestBase manualGenericConcernObj = new ManualNextInvocator(manualGenericConcernMixin);
Int64 t0 = TestInvocationPerformanceInLoop(LOOPS, manualSimple);
Int64 t1 = TestInvocationPerformanceInLoop(LOOPS, manualTypedConcernObj);
Int64 t2 = TestInvocationPerformanceInLoop(LOOPS, manualGenericConcernObj);
Int64 t3 = TestInvocationPerformanceInLoop(LOOPS, ssp.NewPlainCompositeBuilder <TestComposite>().Instantiate());
Int64 t4 = TestInvocationPerformanceInLoop(LOOPS, ssp.NewPlainCompositeBuilder <TestWithTypedConcernComposite>().Instantiate());
Int64 t5 = TestInvocationPerformanceInLoop(LOOPS, ssp.NewPlainCompositeBuilder <TestWithGenericConcernComposite>().Instantiate());
Console.WriteLine("Simple: " + (t3 / t0) + "x");
Console.WriteLine("Typed concern: " + (t4 / t1) + "x");
Console.WriteLine("Generic concern: " + (t5 / t2) + "x");
}
public static void DummyMethod()
{
StructureServiceProvider ssp = null;
Type myCompositeType = null;
#region CompositeCreationCode1
// Acquiring CompositeBuilderInfo
CompositeBuilderInfo <MyComposite> cbi = ssp.NewPlainCompositeBuilder <MyComposite>();
// Acquiring CompositeBuilder, type of composite not known at compile time
CompositeBuilder cb = ssp.NewPlainCompositeBuilder(myCompositeType); // myCompositeType is of System.Type
// Acquiring CompositeBuilder and using multiple types to filter out possible composites
CompositeBuilder cbm = ssp.NewPlainCompositeBuilder(new[] { typeof(MyCompositePartialType1), typeof(MyCompositePartialType2) });
#endregion
{
#region CompositeCreationCode2
MyComposite composite = cbi.Instantiate();
#endregion
}
{
#region CompositeCreationCode3
MyComposite composite = cb.Instantiate <MyComposite>();
MyComposite composite2 = (MyComposite)cb.InstantiateWithType(typeof(MyComposite));
// Both composite and composite2 will be same object.
#endregion
}
{
#region CompositeCreationCode4
MyCompositePartialType1 composite1 = cbm.Instantiate <MyCompositePartialType1>();
MyCompositePartialType2 composite2 = cbm.Instantiate <MyCompositePartialType2>();
// composite1 and composite2 may be different objects.
#endregion
}
}
/// <summary>
/// Helper to create a new <see cref="CompositeBuilder"/> from a specific <see cref="CompositeModel"/>.
/// </summary>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <param name="model">The <see cref="CompositeModel"/> of the composite.</param>
/// <returns>A <see cref="CompositeBuilder"/> to build instances of composites modeled by <see cref="CompositeModel"/>.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, System.Collections.Generic.IEnumerable{Type})"/> method for more exception scenarios.</remarks>
public static CompositeBuilder NewCompositeBuilder(this StructureServiceProvider ssp, CompositeModel model)
{
return(ssp.NewCompositeBuilder(model.ModelType, model.PublicTypes));
}
/// <summary>
/// Helper method to create new <see cref="CompositeBuilder"/> for plain composites (compositem odel type of <see cref="CompositeModelType.PLAIN"/>) with given types to be used as search criterion.
/// </summary>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <param name="compositeTypes">The types of the plain composite.</param>
/// <returns>A new instance of <see cref="CompositeBuilder"/> for plain composites, matching the search criteria.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
public static CompositeBuilder NewPlainCompositeBuilder(this StructureServiceProvider ssp, IEnumerable <Type> compositeTypes)
{
return(ssp.NewCompositeBuilder(CompositeModelType.PLAIN, compositeTypes));
}
/// <summary>
/// Shortcut method to create a composite of specified <see cref="CompositeModelType"/> without further setting up of <see cref="CompositeBuilder"/>.
/// </summary>
/// <typeparam name="TComposite">The type of the composite.</typeparam>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <param name="compositeModelType">The <see cref="CompositeModelType"/> of the composite.</param>
/// <returns>A new instance of composite with given <see cref="CompositeModelType"/>.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> and <see cref="CompositeBuilder.InstantiateWithType(Type)"/> methods for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
/// <seealso cref="CompositeBuilder.InstantiateWithType(Type)"/>
public static TComposite NewComposite <TComposite>(this StructureServiceProvider ssp, CompositeModelType compositeModelType)
{
return(ssp.NewCompositeBuilder <TComposite>(compositeModelType).Instantiate());
}
/// <summary>
/// Shortcut method to create a plain composite (composite with <see cref="CompositeModelType.PLAIN"/> as composite model type) without further setting up of <see cref="CompositeBuilder"/>.
/// </summary>
/// <typeparam name="TComposite">The type of the composite.</typeparam>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <returns>A new instance of plain composite.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> and <see cref="CompositeBuilder.InstantiateWithType(Type)"/> methods for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
/// <seealso cref="CompositeBuilder.InstantiateWithType(Type)"/>
public static TComposite NewPlainComposite <TComposite>(this StructureServiceProvider ssp)
{
return(NewComposite <TComposite>(ssp, CompositeModelType.PLAIN));
}
/// <summary>
/// Helper method to find all suitable services using given type as search criterion.
/// </summary>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <param name="serviceType">The type of the service.</param>
/// <returns>All <see cref="ServiceReference"/>s matching search criterion.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/>
/// <seealso cref="ServiceReference"/>
public static IEnumerable <ServiceReference> FindServices(this StructureServiceProvider ssp, Type serviceType)
{
return(ssp.FindServices(serviceType.Singleton()));
}
/// <summary>
/// Helper method to find all suitable services using single type, known at compile time, as search criterion.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <returns>All <see cref="ServiceReferenceInfo{T}"/>s matching search criterion.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/>
/// <seealso cref="ServiceReferenceInfo{T}"/>
public static IEnumerable <ServiceReferenceInfo <TService> > FindServices <TService>(this StructureServiceProvider ssp)
{
return(ssp.FindServices(typeof(TService).Singleton()).ToArray()
.Select(sRef => new ServiceReferenceInfo <TService>(sRef)));
}
/// <summary>
/// Helper method to find a first suitable <see cref="ServiceReferenceInfo{T}"/> using given type as search criterion.
/// </summary>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <param name="serviceType">The type of the service.</param>
/// <returns>A first <see cref="ServiceReference"/> matching search criterion.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <exception cref="InvalidOperationException">If no suitable services found.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/>
/// <seealso cref="ServiceReference"/>
public static ServiceReference FindService(this StructureServiceProvider ssp, Type serviceType)
{
return(ssp.FindServices(serviceType.Singleton()).First());
}
/// <summary>
/// Helper method to find first suitable <see cref="ServiceReference"/> using given types as search criterion.
/// </summary>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <param name="serviceTypes">The types of the service.</param>
/// <returns>A first <see cref="ServiceReference"/> matching search criterion.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <exception cref="InvalidOperationException">If no suitable services found.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/>
/// <seealso cref="ServiceReference"/>
public static ServiceReference FindService(this StructureServiceProvider ssp, IEnumerable <Type> serviceTypes)
{
return(ssp.FindServices(serviceTypes).First());
}
// TODO implementing value composite model type should be done via extension
//public static CompositeBuilderInfo<TComposite> NewValueBuilder<TComposite>( this StructureServiceProvider ssp )
//{
// return ssp.NewCompositeBuilder<TComposite>( CompositeModelType.VALUE );
//}
//public static CompositeBuilder NewValueBuilder( this StructureServiceProvider ssp, Type compositeType )
//{
// return ssp.NewCompositeBuilder( CompositeModelType.VALUE, compositeType.Singleton() );
//}
//public static CompositeBuilder NewValueBuilder( this StructureServiceProvider ssp, IEnumerable<Type> compositeTypes )
//{
// return ssp.NewCompositeBuilder( CompositeModelType.VALUE, compositeTypes );
//}
/// <summary>
/// Helper method to find a first suitable <see cref="ServiceReferenceInfo{T}"/> using given type, known at compile time, as search criterion.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <returns>A first <see cref="ServiceReferenceInfo{T}"/> matching search criterion.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <exception cref="InvalidOperationException">If no suitable services found.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.FindServices(IEnumerable{Type})"/>
/// <seealso cref="ServiceReferenceInfo{T}"/>
public static ServiceReferenceInfo <TService> FindService <TService>(this StructureServiceProvider ssp)
{
return(ssp.FindServices <TService>().First());
}
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 );
}
/// <summary>
/// Helper method to create new <see cref="CompositeBuilder"/> for plain composites (composite model type of <see cref="CompositeModelType.PLAIN"/>) with only one type to be used as search criterion.
/// </summary>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <param name="compositeType">The type of the plain composite.</param>
/// <returns>A new instance of <see cref="CompositeBuilder"/> for plain composites, matching the search criteria.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
public static CompositeBuilder NewPlainCompositeBuilder(this StructureServiceProvider ssp, Type compositeType)
{
return(ssp.NewCompositeBuilder(CompositeModelType.PLAIN, compositeType.Singleton()));
}
/// <summary>
/// Helper method to create new <see cref="CompositeBuilder"/> for plain composites (composite model type of <see cref="CompositeModelType.PLAIN"/>) with only one type, known at compile time, to be used as search criterion.
/// </summary>
/// <typeparam name="TComposite">The type of the plain composite.</typeparam>
/// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
/// <returns>A new instance of <see cref="CompositeBuilderInfo{T}"/> for plain composites, matching the search criteria.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
/// <seealso cref="CompositeBuilderInfo{T}"/>
public static CompositeBuilderInfo <TComposite> NewPlainCompositeBuilder <TComposite>(this StructureServiceProvider ssp)
{
return(ssp.NewCompositeBuilder <TComposite>(CompositeModelType.PLAIN));
}
/// <summary>
/// Helper method to create new composite builder with specified <see cref="CompositeModelType"/> and only one type, known at compile time, to be used as search criteria.
/// </summary>
/// <typeparam name="TComposite">The type of the composite, to be used as search criterion when searching for suitable composite model.</typeparam>
/// <param name="ssp">The <see cref="StructureServiceProvider"/></param>
/// <param name="compositeModelType">The <see cref="CompositeModelType"/> to be used when searching for suitable composite model.</param>
/// <returns>A new <see cref="CompositeBuilderInfo{T}"/> instance matching the search criteria.</returns>
/// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
/// <remarks>
/// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> method for more exception scenarios.
/// </remarks>
/// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
/// <seealso cref="CompositeBuilderInfo{T}"/>
public static CompositeBuilderInfo <TComposite> NewCompositeBuilder <TComposite>(this StructureServiceProvider ssp, CompositeModelType compositeModelType)
{
return(new CompositeBuilderInfo <TComposite>(ssp.NewCompositeBuilder(compositeModelType, typeof(TComposite).Singleton())));
}
