public static void GAssemblyGroupCommonFinalizer(IGAssemblyGroupBasicConstructorResult gAssemblyGroupBasicConstructorResult)
{
//#region Lookup the Base GAssemblyUnit, GCompilationUnit, GNamespace, GClass, and primary GConstructor, GCompilationUnit gCompilationUnitDerived
//var titularBaseClassName = $"{GAssemblyGroup.GName}Base";
//var titularAssemblyUnitLookupPrimaryConstructorResults = LookupPrimaryConstructorMethod(new List<IGAssemblyGroup>(){GAssemblyGroup},gClassName:titularBaseClassName) ;
//#endregion
//#region Lookup the Derived GAssemblyUnit, GCompilationUnit, GNamespace, and GClass
//var titularClassName = $"{GAssemblyGroup.GName}";
//var titularAssemblyUnitLookupDerivedClassResults = LookupDerivedClass(new List<IGAssemblyGroup>(){GAssemblyGroup},gClassName:titularClassName) ;
//#endregion
#region Create Derived Constructors for all public Base Constructors
// Create a constructor in the Titular class for every public constructor in the Titular Base class
var baseConstructorsList = new List <IGMethod>();
baseConstructorsList.AddRange(gAssemblyGroupBasicConstructorResult.GClassBase.CombinedConstructors());
foreach (var bc in baseConstructorsList)
{
var gConstructor = new GMethod(new GMethodDeclaration(gAssemblyGroupBasicConstructorResult.GClassDerived.GName, isConstructor: true,
gVisibility: "public", gArguments: bc.GDeclaration.GArguments, gBase: bc.GDeclaration.GArguments.ToBaseString()));
gAssemblyGroupBasicConstructorResult.GClassDerived.GMethods.Add(gConstructor.Id, gConstructor);
}
#endregion
#region Constructor Groups
// ToDo handle method groups, will require a change to CombinedConstructors
#endregion
#region Condense GUsings in the Base and Derived GCompilationUnits of the Titular Assembly
#endregion
#region Condense GItemGroups in the GProjectUnit of the Titular Assembly
#endregion
#region Finalize the Statemachine
//(
// IEnumerable<GAssemblyUnit> gAssemblyUnits,
// IEnumerable<GCompilationUnit> gCompilationUnits,
// IEnumerable<GNamespace> gNamespacess,
// IEnumerable<GClass> gClasss,
// IEnumerable<GMethod> gMethods) lookupResultsTuple = LookupPrimaryConstructorMethod();
//MStateMachineFinalizer( GClassBase);
//MStateMachineFinalizer(GTitularBaseCompilationUnit, gNamespace, GClassBase, gConstructorBase, gStateConfigurations);
//MStateMachineFinalizer( GClassBase, gConstructorBase, gStateConfigurations);
MStateMachineFinalizer(gAssemblyGroupBasicConstructorResult);
#endregion
#region Populate Interfaces for Titular Derived and Base Class
PopulateInterface(gAssemblyGroupBasicConstructorResult.GClassDerived, gAssemblyGroupBasicConstructorResult.GTitularInterfaceDerivedInterface);
PopulateInterface(gAssemblyGroupBasicConstructorResult.GClassBase, gAssemblyGroupBasicConstructorResult.GTitularInterfaceBaseInterface);
#endregion
#region populate the Interfaces CompilationUnits for additional classes found in the Titular Derived and Base CompilationUnits
#endregion
#region Condense GUsings in the Base and Derived GCompilationUnits of the Titular Interfaces Assembly
#endregion
#region Condense GItemGroups in the GProjectUnit of the Titular Interfaces Assembly
#endregion
}
public static void GAssemblyGroupGHBSFinalizer(IGAssemblyGroupBasicConstructorResult mCreateAssemblyGroupResult)
{
//#region Lookup the Base GAssemblyUnit, GCompilationUnit, GNamespace, GClass, and primary GConstructor
//var titularBaseClassName = $"{GAssemblyGroup.GName}Base";
//var titularAssemblyUnitLookupPrimaryConstructorResults = LookupPrimaryConstructorMethod(new List<IGAssemblyGroup>(){GAssemblyGroup},gClassName:titularBaseClassName) ;
//#endregion
//#region Lookup the Derived GAssemblyUnit, GCompilationUnit, GNamespace, and GClass
//var titularClassName = $"{GAssemblyGroup.GName}";
//var titularAssemblyUnitLookupDerivedClassResults = LookupDerivedClass(new List<IGAssemblyGroup>(){GAssemblyGroup},gClassName:titularClassName) ;
//#endregion
// No Additional work needed, call CommonFinalizer
GAssemblyGroupCommonFinalizer(mCreateAssemblyGroupResult);
}
public static void GAssemblyGroupGHHSFinalizer(IGAssemblyGroupBasicConstructorResult gAssemblyGroupBasicConstructorResult)
{
//#region Lookup the Base GAssemblyUnit, GCompilationUnit, GNamespace, GClass, and primary GConstructor
//var titularBaseClassName = $"{GAssemblyGroup.GName}Base";
//var titularAssemblyUnitLookupPrimaryConstructorResults = LookupPrimaryConstructorMethod(new List<IGAssemblyGroup>() {GAssemblyGroup}, gClassName: titularBaseClassName);
//var GClassBase = titularAssemblyUnitLookupPrimaryConstructorResults.gClasss.First();
//#endregion
//#region Lookup the Derived GAssemblyUnit, GCompilationUnit, GNamespace, and GClass
//var titularClassName = $"{GAssemblyGroup.GName}";
//var titularAssemblyUnitLookupDerivedClassResults = LookupDerivedClass(new List<IGAssemblyGroup>() {GAssemblyGroup}, gClassName: titularClassName);
//var GClassDerived = titularAssemblyUnitLookupDerivedClassResults.gClasss.First();
//#endregion
//#region Lookup the Interfaces
//var titularInterfaceDerivedName = $"I{GAssemblyGroup.GName}";
//var titularAssemblyUnitLookupDerivedInterfacesResults = LookupInterfaces(new List<IGAssemblyGroup>() {GAssemblyGroup}, gInterfaceName: titularInterfaceDerivedName);
//var gInterfaceDerived = titularAssemblyUnitLookupDerivedInterfacesResults.gInterfaces.First();
//var titularInterfaceBaseName = $"I{GAssemblyGroup.GName}";
//var titularAssemblyUnitLookupBaseInterfacesResults = LookupInterfaces(new List<IGAssemblyGroup>() {GAssemblyGroup}, gInterfaceName: titularInterfaceBaseName);
//var gInterfaceBase = titularAssemblyUnitLookupBaseInterfacesResults.gInterfaces.First();
//#endregion
// No Additional work needed, call CommonFinalizer
GAssemblyGroupCommonFinalizer(gAssemblyGroupBasicConstructorResult);
}
//public static void MStateMachineFinalizer(
// (
// IEnumerable<GAssemblyUnit> gAssemblyUnits,
// IEnumerable<GCompilationUnit> gCompilationUnits,
// IEnumerable<GNamespace> gNamespacess,
// IEnumerable<GClass> gClasss,
// IEnumerable<GMethod> gMethods) lookupResults) {
// MStateMachineFinalizer(lookupResults.gCompilationUnits.First(), lookupResults.gNamespacess.First(),
// lookupResults.gClasss.First(), lookupResults.gMethods.First(), finalGStateConfigurations);
//}
//public static void MStateMachineFinalizer() {
// MStateMachineFinalizer(mCreateAssemblyGroupResult.GTitularBaseCompilationUnit,
// mCreateAssemblyGroupResult.GNamespaceBase, mCreateAssemblyGroupResult.GClassBase,
// gStateConfiguration: mCreateAssemblyGroupResult.GPrimaryConstructorBase.GStateConfigurations);
//}
public static void MStateMachineFinalizer(IGAssemblyGroupBasicConstructorResult mCreateAssemblyGroupResult)
{
#region Accumulate the StateConfigurations
var finalGStateConfiguration = new GStateConfiguration();
foreach (var gAU in mCreateAssemblyGroupResult.GAssemblyGroup.GAssemblyUnits)
{
// finalGStateConfigurations.Add(gAu.GStateConfiguration);
foreach (var gCU in gAU.Value.GCompilationUnits)
{
// finalGStateConfigurations.Add(gCu.GStateConfiguration);
foreach (var gNs in gCU.Value.GNamespaces)
{
// finalGStateConfigurations.Add(gNs.GStateConfiguration);
foreach (var gCl in gNs.Value.GClasss)
{
// finalGStateConfigurations.Add(gCl.GStateConfiguration);
foreach (var gMe in gCl.Value.CombinedMethods())
{
finalGStateConfiguration.GDOTGraphStatements.AddRange(gMe.GStateConfiguration.GDOTGraphStatements);
}
}
}
}
}
#endregion
if (finalGStateConfiguration.GDOTGraphStatements.Any())
{
//var parsedDiGraph = ParseDiGraphToStateMachine(finalGStateConfiguration);
ParseDiGraphToStateMachine(finalGStateConfiguration);
#region StateMachine EnumerationGroups
var gEnumerationGroup = new GEnumerationGroup(gName: "State and Trigger Enumerations for StateMachine");
#region State Enumeration
#region State Enumeration members
var gEnumerationMemberList = new List <IGEnumerationMember>();
var enumerationValue = 1;
foreach (var name in finalGStateConfiguration.GStateNames)
{
gEnumerationMemberList.Add(LocalizableEnumerationMember(name, enumerationValue++));
}
// gEnumerationMemberList = new List<IGEnumerationMember>() {
// LocalizableEnumerationMember("WaitingForInitialization",1,"Power-On State - waiting until minimal initialization condition has been met","Waiting For Initialization"),
// LocalizableEnumerationMember("InitiateContact",1,"Signal to the Console Monitor that we are a valid ConsoleSource","Initiate Contact"),
//};
var gEnumerationMembers = new Dictionary <IPhilote <IGEnumerationMember>, IGEnumerationMember>();
foreach (var o in gEnumerationMemberList)
{
gEnumerationMembers.Add(o.Philote, o);
}
#endregion
var gEnumeration = new GEnumeration(gName: "State", gVisibility: "public", gInheritance: "",
gEnumerationMembers: gEnumerationMembers);
#endregion
gEnumerationGroup.GEnumerations.Add(gEnumeration.Philote, gEnumeration);
#region Trigger Enumeration
#region Trigger Enumeration members
gEnumerationMemberList = new List <IGEnumerationMember>();
enumerationValue = 1;
foreach (var name in finalGStateConfiguration.GTriggerNames)
{
gEnumerationMemberList.Add(LocalizableEnumerationMember(name, enumerationValue++));
}
//gEnumerationMemberList = new List<IGEnumerationMember>() {
// LocalizableEnumerationMember("InitializationCompleteReceived",1,"The minimal initialization conditions have been met","Initialization Complete Received"),
//};
gEnumerationMembers =
new Dictionary <IPhilote <IGEnumerationMember>, IGEnumerationMember
>(); //{gEnumerationMemberList.ForEach(m=>m.Philote,m)};
foreach (var o in gEnumerationMemberList)
{
gEnumerationMembers.Add(o.Philote, o);
}
#endregion
gEnumeration =
new GEnumeration(gName: "Trigger", gVisibility: "public", gInheritance: "",
gEnumerationMembers: gEnumerationMembers);
gEnumerationGroup.GEnumerations.Add(gEnumeration.Philote, gEnumeration);
#endregion
mCreateAssemblyGroupResult.GNamespaceBase.AddEnumerationGroup(gEnumerationGroup);
#endregion
//#region StateMachine Transitions Static variable
//// Add a StaticVariable to the class
//List<string> gStatements = new List<string>() {"new List<StateConfiguration>(){"};
//foreach (var sc in parsedDiGraph.StateConfigurations) {
// gStatements.Add(sc);
//}
//gStatements.Add("}");
//var gStaticVariable = new GStaticVariable("stateConfigurations", gType: "List<StateConfiguration>",
// gBody: new GBody(gStatements));
//gClass.GStaticVariables.Add(gStaticVariable.Philote, gStaticVariable);
//#endregion
#region Create the detailed ConfigureStateMachine Method using the parsedDiGraph information
// add a method to the class that configures the StateMachine according to the StateConfigurations parsed from the diGraph
var gMethodGroup = new GMethodGroup(gName: "Detailed ConfigureStateMachine Method");
var gBody = new GBody(new List <string>());
var gMethod =
new GMethod(
new GMethodDeclaration(gName: "ConfigureStateMachine", gType: "void", gVisibility: "private",
gAccessModifier: ""), gBody);
//"// attribution :https://github.com/dhrobbins/ApprovaFlow/blob/master/ApprovaFlow/ApprovaFlow/ApprovaFlow/Workflow/WorkflowProcessor.cs",
//"// attribution :https://github.com/frederiksen/Stateless-Designer/blob/master/src/StatelessDesigner.VS2017/StatelessCodeGenerator/StatelessCodeGenerator.cs",
//"// Heavily modified to work in a code generator",
//"",
//gBody.GStatements.Add(
// "#region Delegates for each state's Entry and Exit method calls, and GuardClauses method calls");
foreach (var stateName in finalGStateConfiguration.GStateNames)
{
gBody.GStatements.Add($"StateMachine.Configure(State.{stateName})");
var permittedStateTransitions = finalGStateConfiguration.GDiGraphStates.Where(x => x.state == stateName)
.Select(x => (triggerName: x.trigger, nextStateName: x.nextstate));
foreach (var pST in permittedStateTransitions)
{
gBody.GStatements.Add($" .Permit(Trigger.{pST.triggerName},State.{pST.nextStateName})");
}
gBody.GStatements.Add($";");
// $"public EntryExitDelegate On{stateName}Entry = null;",
// $"public EntryExitDelegate On{stateName}Exit = null;",
}
;
//}
//gBody.GStatements.Add("#endregion");
//gBody.GStatements.Add("#region Fluent");
//foreach (var stateConfiguration in parsedDiGraph.StateConfigurations) {
// //gBody.GStatements. Add("StateMachine.Configure($State},");
// // if (true) // stateName == stateConfiguration) {
// // gBody.GStatements.Add($"#endregion");
//}
// gBody.GStatements.Add("#endregion");
//gBody.GStatements.AddRange(
// "#region Delegates for each state's Entry and Exit method calls, and GuardClauses method calls",
// "#endregion "
// );
//"// Get a distinct list of states with a trigger from the stateConfigurations static variable",
//"// State => Trigger => TargetState",
//"var states = StateConfigurations.AsQueryable()",
//".Select(x => x.State)",
//".Distinct()",
//".Select(x => x)",
//".ToList();",
//"// Get each trigger for each state",
//"states.ForEach(state =>{",
//"var triggers = StateConfigurations.AsQueryable()",
//".Where(config => config.State == state)",
//".Select(config => new { Trigger = config.Trigger, TargetState = config.NextState })",
//".ToList();",
//"triggers.ForEach(trig => {",
//"StateMachine.Configure(state).Permit(trig.Trigger, trig.TargetState);",
//" });",
//"});",
#endregion
gMethodGroup.GMethods.Add(gMethod.Philote, gMethod);
mCreateAssemblyGroupResult.GClassBase.GMethodGroups.Add(gMethodGroup.Philote, gMethodGroup);
#region Add the statement that fires the InitializationCompleteReceived Trigger
//var statementList = gClass.CombinedMethods().Where(x => x.GDeclaration.GName == "StartAsync").First().GBody
// .GStatements;
//statementList.Insert(statementList.Count - 1, "StateMachine.Fire(Trigger.InitializationCompleteReceived);");
#endregion
}
}
//#region Titular Base Class (IHostedService)
// GClass gClass = new GClass(gCompilationUnitName, gVisibility: "public",
// gInheritance: "BackgroundService",
// gImplements: new List<string> { "IDisposable" },
// gDisposesOf: new List<string> { "SubscriptionToConsoleReadLineAsyncAsObservableDisposeHandle" });
// #region specific methods for BackgroundService
// gClass.AddMethod(MCreateExecuteAsyncMethod(gAccessModifier: "override async"));
// gClass.AddMethodGroup(MCreateStartStopAsyncMethods(gAccessModifier: "override async"));
// #endregion
// #region Constructors
// gConstructor = new GMethod(new GMethodDeclaration(gCompilationUnitName, isConstructor: true,
// gVisibility: "public"));
// gClass.GMethods.Add(gConstructor.Philote,gConstructor);
// #endregion
public static void MAssemblyGroupCommonConstructorForGHHSAndGHBSPart2(
IGAssemblyGroupBasicConstructorResult mCreateAssemblyGroupResult)
{
#region Add a StateMachine for the service
#region Declare and populate the initial initialDiGraphList, which handles basic states for a GHS
List <string> initialDiGraphList = new List <string>()
{
@"WaitingForInitialization ->ServiceFaulted [label = ""AnyException""]",
@"WaitingForInitialization ->ShutdownStarted [label = ""StopAsyncActivated""]",
@"ServiceFaulted ->ShutdownStarted [label = ""CancellationTokenActivated""]",
@"ServiceFaulted ->ShutdownStarted [label = ""StopAsyncActivated""]",
@"ShutdownStarted->ShutDownComplete [label = ""AllShutDownStepsCompleted""]",
};
#endregion
MStateMachineConstructor(mCreateAssemblyGroupResult.GTitularBaseCompilationUnit, mCreateAssemblyGroupResult.GNamespaceBase, mCreateAssemblyGroupResult.GClassBase, mCreateAssemblyGroupResult.GPrimaryConstructorBase, initialDiGraphList);
#endregion
#region ResourceUnits
GResourceUnit gResourceUnit;
GResourceItem gResourceItem;
Dictionary <IPhilote <IGResourceItem>, IGResourceItem> gResourceItems;
GPatternReplacement gExceptionMessagesResourcePatternReplacement = new GPatternReplacement(
gDictionary: new Dictionary <Regex, string>()
{
{ new Regex("ExceptionMessagesResourceUnitNameReplacementPattern"), "AssemblyUnitNameReplacementPattern" }
});
gExceptionMessagesResourcePatternReplacement.GDictionary.AddRange(mCreateAssemblyGroupResult.GTitularAssemblyUnitPatternReplacement.GDictionary);
gResourceItem = new GResourceItem(gName: "ExceptionMessage1", gValue: "text for exception {0}",
gComment: "{0} is the exception something?");
gResourceItems = new Dictionary <IPhilote <IGResourceItem>, IGResourceItem> {
[gResourceItem.Philote] = gResourceItem
};
gResourceUnit =
new GResourceUnit("ExceptionMessages", gRelativePath: "Resources", gResourceItems: gResourceItems,
gPatternReplacement: gExceptionMessagesResourcePatternReplacement);
mCreateAssemblyGroupResult.GTitularAssemblyUnit.GResourceUnits.Add(gResourceUnit.Philote, gResourceUnit);
mCreateAssemblyGroupResult.GTitularAssemblyUnit.GProjectUnit.GResourceUnits.Add(gResourceUnit.Philote, gResourceUnit);
GPatternReplacement gUIMessagesResourcePatternReplacement = new GPatternReplacement(
gDictionary: new Dictionary <Regex, string>()
{
{ new Regex("ExceptionMessagesResourceUnitNameReplacementPattern"), "AssemblyUnitNameReplacementPattern" }
});
gUIMessagesResourcePatternReplacement.GDictionary.AddRange(mCreateAssemblyGroupResult.GTitularAssemblyUnitPatternReplacement.GDictionary);
gResourceItem = new GResourceItem(gName: "Enter Selection>", gValue: "Enter Selection>",
gComment: "Enter Selection prompt for Console UI");
gResourceItems = new Dictionary <IPhilote <IGResourceItem>, IGResourceItem> {
[gResourceItem.Philote] = gResourceItem
};
gResourceUnit = new GResourceUnit("UIMessages", gRelativePath: "Resources", gResourceItems: gResourceItems,
gPatternReplacement: gUIMessagesResourcePatternReplacement);
mCreateAssemblyGroupResult.GTitularAssemblyUnit.GResourceUnits.Add(gResourceUnit.Philote, gResourceUnit);
mCreateAssemblyGroupResult.GTitularAssemblyUnit.GProjectUnit.GResourceUnits.Add(gResourceUnit.Philote, gResourceUnit);
#endregion
//#region StringConstants Base CompilationUnit
//mCreateAssemblyGroupResult.GTitularBaseCompilationUnitPatternReplacement = new GPatternReplacement(
// gDictionary: new Dictionary<Regex, string>() {
// {new Regex("CompilationUnitNameReplacementPattern"), "AssemblyUnitNameReplacementPattern"}
// });
//foreach (var kvp in mCreateAssemblyGroupResult.gAssemblyUnitPatternReplacement.GDictionary) {
// mCreateAssemblyGroupResult.GTitularBaseCompilationUnitPatternReplacement.GDictionary.Add(kvp.Key, kvp.Value);
//}
#region DefaultConfiguration CompilationUnit
#region GPatternReplacement for the DefaultConfiguration CompilationUnit
var gTitularAssemblyUnitDefaultConfigurationPatternReplacement =
new GPatternReplacement(gName: "gTitularAssemblyUnitDefaultConfigurationPatternReplacement");
gTitularAssemblyUnitDefaultConfigurationPatternReplacement.GDictionary.AddRange(
mCreateAssemblyGroupResult.GTitularAssemblyUnitPatternReplacement.GDictionary);
#endregion
#region Additional DefaultConfiguration items
var gAdditionalStatements = new List <string>()
{
"{dummyConfigKeyRoot,dummyConfigDefaultString}"
};
#endregion
var gCompilationUnit = CompilationUnitDefaultConfigurationConstructor(gNamespaceName: mCreateAssemblyGroupResult.GNamespaceDerived.GName,
gRelativePath: mCreateAssemblyGroupResult.SubDirectoryForGeneratedFiles, gAdditionalStatements: gAdditionalStatements,
gPatternReplacement: gTitularAssemblyUnitDefaultConfigurationPatternReplacement);
mCreateAssemblyGroupResult.GTitularAssemblyUnit.GCompilationUnits.Add(gCompilationUnit.Philote, gCompilationUnit);
#endregion
#region Settings File(s) for Configuration
#endregion
#region Upate the ProjectUnit in the Titular AssemblyUnit
#region ItemGroups for the ProjectUnit
var gItemGroupInProjectUnitList = MGenericHostServiceCommonItemGroupInProjectUnitList();
gItemGroupInProjectUnitList.ForEach(o =>
mCreateAssemblyGroupResult.GTitularAssemblyUnit.GProjectUnit.GItemGroupInProjectUnits.Add(o.Philote, o));
//_projectReferences.ForEach(o =>
// gAssemblyUnit.GProjectUnit.GItemGroupInProjectUnits.Add(o.Philote, o));
//_packageReferences.ForEach(o =>
// gAssemblyUnit.GProjectUnit.GItemGroupInProjectUnits.Add(o.Philote, o));
#endregion
#endregion
// GAssemblyGroup.GAssemblyUnits.Add(gAssemblyUnit.Philote, gAssemblyUnit);
/* ************************************************************************************ */
//#region Interfaces
//#region Pattern Replacements for AssemblyUnit
//gAssemblyUnitPatternReplacement = new GPatternReplacement(gDictionary: new Dictionary<Regex, string>() {
// {new Regex("AssemblyUnitNameReplacementPattern"), $"{GAssemblyGroupName}"}
//});
//foreach (var kvp in gAssemblyGroupPatternReplacement.GDictionary) {
// gAssemblyUnitPatternReplacement.GDictionary.Add(kvp.Key, kvp.Value);
//}
//#endregion
//#region Create AssemblyUnit for Interfaces
//gAssemblyUnitName = $"{GAssemblyGroupName}.Interfaces";
//gAssemblyUnit = new GAssemblyUnit($"{gAssemblyUnitName}",
// gRelativePath: $"{gAssemblyUnitName}",
// gProjectUnit: new GProjectUnit($"{gAssemblyUnitName}",
// gPatternReplacement: gAssemblyUnitPatternReplacement), gPatternReplacement: gAssemblyUnitPatternReplacement);
//#endregion
//#region Pattern Replacements for CompilationUnit
//gCompilationUnitPatternReplacement = new GPatternReplacement(gDictionary: new Dictionary<Regex, string>() {
// {new Regex("CompilationUnitNameReplacementPattern"), "AssemblyUnitNameReplacementPattern"}
//});
//foreach (var kvp in gAssemblyUnitPatternReplacement.GDictionary) {
// gCompilationUnitPatternReplacement.GDictionary.Add(kvp.Key, kvp.Value);
//}
//#endregion
//#region Create CompilationUnit for Titular Base Interface CompilationUnit
//var compilationUnitName = $"I{baseCompilationUnitName}";
//gCompilationUnit = new GCompilationUnit($"{compilationUnitName}", gFileSuffix: ".cs",
// gRelativePath: SubDirectoryForGeneratedFiles, gPatternReplacement: gCompilationUnitPatternReplacement);
//gAssemblyUnit.GCompilationUnits.Add(gCompilationUnit.Philote, gCompilationUnit);
#region Usings For Titular Base Interface CompilationUnit
var gUsingGroup = MUsingGroupForMicrosoftGenericHostInGHHSAndGHBS();
mCreateAssemblyGroupResult.GTitularInterfaceBaseCompilationUnit.GUsingGroups.Add(gUsingGroup.Philote, gUsingGroup);
gUsingGroup = MUsingGroupForSystemGenericHostInGHHSAndGHBS();
mCreateAssemblyGroupResult.GTitularInterfaceBaseCompilationUnit.GUsingGroups.Add(gUsingGroup.Philote, gUsingGroup);
#endregion
//#region Namespace For Titular Base Interface CompilationUnit
//gNamespace = new GNamespace($"{BaseNamespaceName}.{GAssemblyGroupName}");
//gCompilationUnit.GNamespaces.Add(gNamespace.Philote, gNamespace);
//#endregion
//#region Create Interface for Titular Base Interface CompilationUnit (IHostedService)
//var baseInterfaceName = $"I{baseCompilationUnitName}";
//var gInterface = new GInterface(baseInterfaceName, "public");
//gNamespace.GInterfaces.Add(gInterface.Philote, gInterface);
//#endregion
//#endregion
#region Create CompilationUnit for Titular Interface CompilationUnit
//compilationUnitName = $"I{GAssemblyGroupName}";
//gCompilationUnit = new GCompilationUnit($"{compilationUnitName}", gFileSuffix: ".cs",
// gRelativePath: SubDirectoryForGeneratedFiles, gPatternReplacement: gCompilationUnitPatternReplacement);
//gAssemblyUnit.GCompilationUnits.Add(gCompilationUnit.Philote, gCompilationUnit);
#region Usings For Titular Interface CompilationUnit
gUsingGroup = MUsingGroupForSystemGenericHostInGHHSAndGHBS();
mCreateAssemblyGroupResult.GTitularInterfaceDerivedCompilationUnit.GUsingGroups.Add(gUsingGroup.Philote, gUsingGroup);
#endregion
//#region Namespace For Titular Interface CompilationUnit
//gNamespace = new GNamespace($"{BaseNamespaceName}.{GAssemblyGroupName}");
//gCompilationUnit.GNamespaces.Add(gNamespace.Philote, gNamespace);
//#endregion
//#region Create Interface for Titular Interface CompilationUnit (IHostedService)
//var titularInterfaceName = $"I{GAssemblyGroupName}";
//gInterface = new GInterface(titularInterfaceName, "public",
// gImplements: new List<string>() {$"{baseInterfaceName}"});
//gNamespace.GInterfaces.Add(gInterface.Philote, gInterface);
//#endregion
#endregion
#region Upate the ProjectUnit in the Interfaces AssemblyUnit
//#region PropertyGroups for the ProjectUnit in the Interfaces AssemblyUnit
//var gPropertyGroupInProjectUnit = PropertyGroupInProjectUnitForProjectUnitIsLibrary();
//gAssemblyUnit.GProjectUnit.GPropertyGroupInProjectUnits[gPropertyGroupInProjectUnit.Philote] =
// gPropertyGroupInProjectUnit;
//gPropertyGroupInProjectUnit = PropertyGroupInProjectUnitForPackableOnBuild();
//gAssemblyUnit.GProjectUnit.GPropertyGroupInProjectUnits[gPropertyGroupInProjectUnit.Philote] =
// gPropertyGroupInProjectUnit;
//gPropertyGroupInProjectUnit = PropertyGroupInProjectUnitForLifecycleStage();
//gAssemblyUnit.GProjectUnit.GPropertyGroupInProjectUnits[gPropertyGroupInProjectUnit.Philote] =
// gPropertyGroupInProjectUnit;
//gPropertyGroupInProjectUnit = PropertyGroupInProjectUnitForBuildConfigurations();
//gAssemblyUnit.GProjectUnit.GPropertyGroupInProjectUnits[gPropertyGroupInProjectUnit.Philote] =
// gPropertyGroupInProjectUnit;
//gPropertyGroupInProjectUnit = PropertyGroupInProjectUnitForVersion();
//gAssemblyUnit.GProjectUnit.GPropertyGroupInProjectUnits[gPropertyGroupInProjectUnit.Philote] =
// gPropertyGroupInProjectUnit;
//#endregion
#region ItemGroups for the ProjectUnit in the Interfaces AssemblyUnit
new List <IGItemGroupInProjectUnit>()
{
NetCoreGenericHostReferencesItemGroupInProjectUnit(),
}.ForEach(o => mCreateAssemblyGroupResult.gTitularInterfaceAssemblyUnit.GProjectUnit.GItemGroupInProjectUnits.Add(o.Philote, o));
#endregion
#endregion
//GAssemblyGroup.GAssemblyUnits.Add(gAssemblyUnit.Philote, gAssemblyUnit);
//#endregion
//return GAssemblyGroup;
}
