private ClassSyntax BuildMethod_GetParserAction(ClassSyntax context) { var generator = new ReadOnlyTableGenerator( data.ParserActionTable, il => il.Ldarg(0), il => il.Ldarg(1)); var args = context.Method() .Private.Static .Returning(context.Types.Int32) .Named(GetParserActionMethodName) .BeginArgs(); return(args .Argument(context.Types.Int32, args.Args.Generate()) .Argument(context.Types.Int32, args.Args.Generate()) .EndArgs() .NoOptimization .BeginBody() .Do(generator.Build) .Ret() .EndBody()); }
public void ClassSyntax_GetInheritance_WhenFlagsNotSet_ShouldReturnDefault() { TypeDef typeDef = new TypeDef(); ClassSyntax syntax = new ClassSyntax(typeDef); Assert.AreEqual(Inheritance.Default, syntax.GetInheritance()); }
/// <summary> /// Foramts the class base portion of a class decleration. /// </summary> /// <param name="syntax">The syntax details for the class.</param> /// <returns>The string representing the class base.</returns> public List <SyntaxToken> FormatClassBase(ClassSyntax syntax) { List <SyntaxToken> tokens = new List <SyntaxToken>(); bool hasBaseType = false; // Create the list of types and interfaces List <SyntaxToken> baseTypesAndInterfaces = new List <SyntaxToken>(); if (syntax.Class.InheritsFrom != null && syntax.Class.InheritsFrom.GetFullyQualifiedName() != "System.Object") { tokens.Add(new SyntaxToken(" : ", SyntaxTokens.Text)); tokens.AddRange(FormatTypeDetails(syntax.GetBaseClass())); hasBaseType = true; } Signatures.TypeDetails[] details = syntax.GetInterfaces(); for (int i = 0; i < details.Length; i++) { if (!hasBaseType && i == 0) { tokens.Add(new SyntaxToken(": ", SyntaxTokens.Text)); } else if (hasBaseType && i == 0 || i != 0) { tokens.Add(new SyntaxToken($",\n\t", SyntaxTokens.Text)); } tokens.AddRange(FormatTypeDetails(details[i])); } return(tokens); }
private ClassSyntax BuildMethod_CreateStateToSymbol(ClassSyntax context) { var emit = context .Method() .Private.Static .Returning(context.Types.Import(typeof(int[]))) .Named(CreateStateToSymbolMethodName) .BeginArgs() .EndArgs() .BeginBody(); var resultLoc = emit.Locals.Generate().GetRef(); var stateToSymbol = data.StateToToken; emit = emit .Local(resultLoc.Def, context.Types.Import(typeof(int[]))) .Ldc_I4(stateToSymbol.Length) .Newarr(context.Types.Import(typeof(int))) .Stloc(resultLoc); for (int i = 0; i != stateToSymbol.Length; ++i) { emit = emit .Ldloc(resultLoc) .Ldc_I4(i) .Ldc_I4(stateToSymbol[i]) .Stelem_I4(); } return(emit .Ldloc(resultLoc) .Ret() .EndBody()); }
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data) { var args = context.Method() .Static .Returning(context.Types.Object) .Named(methodName) .BeginArgs(); Def <Args> tokenId = args.Args.Generate("token"); Def <Args> oldValue = args.Args.Generate("oldValue"); Def <Args> newValue = args.Args.Generate("newValue"); Def <Args> ctx = args.Args.Generate("rootContext"); Def <Args> stackLookback = args.Args.Generate("startLookback"); var emit = args .Argument(context.Types.Int32, tokenId) .Argument(context.Types.Object, oldValue) .Argument(context.Types.Object, newValue) .Argument(context.Types.Object, ctx) .Argument(context.Types.Import(typeof(IStackLookback <Msg>)), stackLookback) .EndArgs() .BeginBody(); BuildBody( emit, data, tokenId.GetRef(), oldValue.GetRef(), newValue.GetRef(), ctx.GetRef(), stackLookback.GetRef()); return(emit.EndBody()); }
private ClassSyntax BuildMethod_TermFactory(ClassSyntax context) { var args = context .Method() .Static .Returning(context.Types.Int32) .Named(TermFactoryMethodName) .BeginArgs(); var cursorArg = args.Args.Generate("cursor"); var tokenArg = args.Args.Generate("token"); var emit = args .Argument(context.Types.Import(typeof(ScanCursor)), cursorArg) // ruleId .Out.Argument(context.Types.Import(typeof(object).MakeByRefType()), tokenArg) .EndArgs() .BeginBody(); var generator = new TermFactoryGenerator(data, declaringTypeRef); generator.Build( emit, il => il.Ldarg(cursorArg.GetRef()), il => il.Ldarg(tokenArg.GetRef())); return(emit.EndBody()); }
/// <summary> /// Formats the provided <paramref name="syntax"/> instance based on a /// c# class decleration. /// </summary> /// <param name="syntax">The syntax for format.</param> /// <returns>A fully formatted c# class decleration.</returns> public SyntaxTokenCollection Format(ClassSyntax syntax) { SyntaxTokenCollection tokens = new SyntaxTokenCollection(); SyntaxToken inheritanceModifier = FormatInheritance(syntax); tokens.AddRange(FormatVisibility(syntax)); if (inheritanceModifier != null) { tokens.Add(Constants.Space); tokens.Add(inheritanceModifier); } tokens.Add(Constants.Space); tokens.Add(Constants.KeywordClass); tokens.Add(Constants.Space); tokens.Add(new SyntaxToken(syntax.GetIdentifier(), SyntaxTokens.Text)); if (_syntax.Class.IsGeneric) { List <GenericTypeRef> genericTypes = _syntax.GetGenericParameters(); tokens.AddRange(FormatGenericParameters(genericTypes)); } tokens.AddRange(FormatClassBase(syntax)); return(tokens); }
private ClassSyntax BuildMethod_MergeAction(ClassSyntax context) { var generator = new MergeActionGenerator(); generator.BuildMethod(context, MergeActionMethodName, data); return(context); }
public ClassDeclaration(ClassSyntax syntax) : base(syntax.Name.ValueText) { Syntax = new List <ClassSyntax>(1) { syntax }; }
public void ClassSyntax_GetInheritance_WhenFlagsAbstract_ShouldReturnAbstract() { TypeDef typeDef = new TypeDef(); ClassSyntax syntax = new ClassSyntax(typeDef); typeDef.Flags = Reflection.Core.COFF.TypeAttributes.Abstract; Assert.AreEqual(Inheritance.Abstract, syntax.GetInheritance()); }
public void ClassSyntax_GetInheritance_WhenFlagsSealed_ShouldReturnSealed() { TypeDef typeDef = new TypeDef(); ClassSyntax syntax = new ClassSyntax(typeDef); typeDef.Flags = Reflection.Core.COFF.TypeAttributes.Sealed; Assert.AreEqual(Inheritance.Sealed, syntax.GetInheritance()); }
public BoundType(string name, ClassSyntax syntax) : base(syntax) { Name = name; Type = new TypeCompilerGeneratedType(); FieldsInternal = new List<BoundField>(); ConstructorsInternal = new List<BoundConstructor>(); FunctionsInternal = new List<BoundFunction>(); }
public void ClassSyntax_GetIdentifier(string name, bool isGeneric, string expectedResult) { TypeDef typeDef = new TypeDef(); ClassSyntax syntax = new ClassSyntax(typeDef); typeDef.IsGeneric = isGeneric; typeDef.Name = name; string result = syntax.GetIdentifier(); Assert.AreEqual(expectedResult, result); }
public void ClassSyntax_GetInterfaces_WhenTypeImplementsNothing_ShouldReturnNoEntries() { TypeDef typeDef = new TypeDef(); ClassSyntax syntax = new ClassSyntax(typeDef); typeDef.Implements = new System.Collections.Generic.List <TypeRef>(); Array result = syntax.GetInterfaces(); Assert.IsNotNull(result); Assert.AreEqual(0, result.Length); }
public virtual void Visit(ClassSyntax classSyntax) { foreach (var fieldSyntax in classSyntax.Fields) { Visit(fieldSyntax); } foreach (var constructorSyntax in classSyntax.Constructors) { Visit(constructorSyntax); } foreach (var functionSyntax in classSyntax.Functions) { Visit(functionSyntax); } }
private ClassSyntax BuildMethod_CreateTokenIdentities(ClassSyntax context) { var generator = new TokenIdentitiesSerializer(data.Grammar); return(context .Method().Private.Static .Returning(context.Types.Import(LanguageBase.Fields.tokenKeyToId.FieldType)) .Named(CreateTokenKeyToIdMethodName) .BeginArgs() .EndArgs() .BeginBody() .Do(generator.Build) .Ret() .EndBody()); }
private ClassSyntax BuildMethod_CreateDefaultContext(ClassSyntax context) { return(context .Method() .Private.Static .Returning(context.Types.Object) .Named(CreateDefaultContextMethodName) .BeginArgs() .EndArgs() .BeginBody() // Plan implementation of abstraction as needed .Do(il => implementationGenerator .EmitFactoryCode(il, languageName.DefinitionType)) .Ret() .EndBody()); }
private ClassSyntax BuildMethod_CreateGrammar(ClassSyntax context) { var grammarSerializer = new GrammarSerializer(data.Grammar); return(context .Method() .Private.Static .Returning(context.Types.Import(typeof(Grammar))) .Named(CreateGrammarMethodName) .BeginArgs() .EndArgs() .BeginBody() .Do(grammarSerializer.Build) .Ret() .EndBody()); }
private ClassSyntax BuildMethod_Scan1(ClassSyntax context) { logging.Write( new LogEntry { Severity = Severity.Verbose, Message = string.Format("Started compiling Scan1 modes for {0} language", languageName.LanguageName) }); foreach (var condition in data.Grammar.Conditions) { ITdfaData dfa = condition.Joint.The <ITdfaData>(); var dfaSerialization = new DfaSerialization(dfa); var generator = new ScannerGenerator(dfaSerialization); var methodName = ConditionMethods.GetMethodName(condition.Index); var args = context .Method() .Static .Returning(context.Types.Int32) .Named(methodName) .BeginArgs(); var emit = args .Argument( context.Types.Import(typeof(ScanCursor)), args.Args.Generate("cursor")) // input .EndArgs() .NoInlining .NoOptimization .BeginBody(); generator.Build(emit); context = emit.EndBody(); } logging.Write( new LogEntry { Severity = Severity.Verbose, Message = string.Format("Done compiling Scan1 modes for {0} language", languageName.LanguageName) }); return(context); }
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data) { var args = context.Method() .Static .Returning(context.Types.Object) .Named(methodName) .BeginArgs(); Def <Args> ruleId = args.Args.Generate("ruleId"); Def <Args> ruleArgs = args.Args.Generate("ruleArgs"); Def <Args> argsStart = args.Args.Generate("argsStart"); Def <Args> ctx = args.Args.Generate("rootContext"); Def <Args> stackLookback = args.Args.Generate("startLookback"); var emit = args .Argument(context.Types.Int32, ruleId) .Argument(context.Types.Import(typeof(Msg[])), ruleArgs) .Argument(context.Types.Int32, argsStart) .Argument(context.Types.Object, ctx) .Argument(context.Types.Import(typeof(IStackLookback <Msg>)), stackLookback) .EndArgs() .BeginBody(); ruleId.Name = "ruleId"; ruleArgs.Name = "args"; argsStart.Name = "argsStart"; ctx.Name = "ctx"; stackLookback.Name = "stackLookback"; BuildBody( emit, data, ruleId.GetRef(), ruleArgs.GetRef(), argsStart.GetRef(), ctx.GetRef(), stackLookback.GetRef()); return(emit.EndBody()); }
public void ClassSyntax_GetInterfaces_WhenTypeImplementsNonTypeSpecEntries_ShouldReturnEntries() { TypeDef typeDef = new TypeDef(); ClassSyntax syntax = new ClassSyntax(typeDef); typeDef.Implements = new System.Collections.Generic.List <TypeRef>() { new TypeRef { Name = "First" }, new TypeRef { Name = "Second" } }; // cant test this with typespec entries yet as there is an internal load which requires us to be // able to set private variables. Array result = syntax.GetInterfaces(); Assert.AreEqual(2, result.Length); }
public List <SyntaxToken> FormatClassBase(ClassSyntax syntax) { List <SyntaxToken> tokens = new List <SyntaxToken>(); bool hasBaseType = false; // Create the list of types and interfaces if (syntax.Class.InheritsFrom != null && syntax.Class.InheritsFrom.GetFullyQualifiedName() != "System.Object") { hasBaseType = true; } if (hasBaseType) { tokens.Add(new SyntaxToken("Derives", SyntaxTokens.Keyword)); tokens.Add(Constants.Space); tokens.AddRange(FormatTypeDetails(syntax.GetBaseClass())); } Signatures.TypeDetails[] interfaces = syntax.GetInterfaces(); for (int i = 0; i < interfaces.Length; i++) { if (i == 0) { tokens.Add(new SyntaxToken(" _\n\t", SyntaxTokens.Text)); tokens.Add(new SyntaxToken("Implements", SyntaxTokens.Keyword)); tokens.Add(Constants.Space); } else if (hasBaseType && i == 0 || i != 0) { tokens.Add(new SyntaxToken(", _\n\t\t", SyntaxTokens.Text)); } tokens.AddRange(FormatTypeDetails(interfaces[i])); } return(tokens); }
private ClassSyntax BuildMethod_CreateParserActionConflicts(ClassSyntax context) { var emit = context .Method() .Private.Static .Returning(context.Types.Import(typeof(int[]))) .Named(CreateParserActionConflictsMethodName) .BeginArgs() .EndArgs() .BeginBody(); var resultLoc = emit.Locals.Generate().GetRef(); var itemLoc = emit.Locals.Generate().GetRef(); var conflicts = data.ParserConflictActionTable; emit = emit .Local(resultLoc.Def, emit.Types.Import(typeof(int[]))) .Ldc_I4(conflicts.Length) .Newarr(emit.Types.Import(typeof(int))) .Stloc(resultLoc) ; for (int i = 0; i != conflicts.Length; ++i) { emit .Ldloc(resultLoc) .Ldc_I4(i) .Ldc_I4(conflicts[i]) .Stelem_I4(); } return(emit .Ldloc(resultLoc) .Ret() .EndBody()); }
private ClassSyntax BuildMethod_CreateTokenComplexityTable(ClassSyntax context) { var emit = context .Method() .Private.Static .Returning(context.Types.Import(typeof(int[]))) .Named(CreateTokenComplexityTableMethodName) .BeginArgs() .EndArgs() .BeginBody(); var resultLoc = emit.Locals.Generate().GetRef(); var itemLoc = emit.Locals.Generate().GetRef(); var table = data.TokenComplexity; emit = emit .Local(resultLoc.Def, emit.Types.Import(typeof(int[]))) .Ldc_I4(table.Length) .Newarr(emit.Types.Import(typeof(int))) .Stloc(resultLoc) ; for (int i = 0; i != table.Length; ++i) { emit .Ldloc(resultLoc) .Ldc_I4(i) .Ldc_I4(table[i]) .Stelem_I4(); } return(emit .Ldloc(resultLoc) .Ret() .EndBody()); }
private CilDocumentSyntax GenerateImpl(PlannedClass entry, CilDocumentSyntax cil) { ClassExtendsSyntax wantBaseClass = cil.Class_() .Public .Named(entry.ClassName) ; var baseClassRef = cil.Types.Import(entry.BaseClass); ClassImplementsSyntax wantContract = wantBaseClass .Extends(baseClassRef); var baseCtor = entry.BaseClass.GetConstructor(Type.EmptyTypes); Ref <Methods> baseCtorRef; if (baseCtor != null) { baseCtorRef = cil.Methods.Import(baseCtor); } else { baseCtorRef = null; } foreach (Type c in entry.Contracts) { wantContract = wantContract.Implements(cil.Types.Import(c)); } ClassSyntax classCode = wantContract; classCode = classCode .Method() .Public.Instance .Returning(classCode.Types.Void) .Named(".ctor") .BeginArgs().EndArgs() .BeginBody() .Do(il => { if (baseCtorRef != null) { il = il .Ldarg(0) .Callvirt(baseCtorRef); } return(il); }) .Ret() .EndBody() ; foreach (var method in entry.Methods) { WantArgsBase wantArgs = classCode.Method() .Private.Hidebysig.Newslot .Virtual.Final.Instance .Returning(classCode.Types.Import(method.ReturnType)) .Named(method.DeclaringType + "." + method.Name) .BeginArgs(); foreach (var parameter in method.GetParameters()) { wantArgs = wantArgs.Argument( classCode.Types.Import(parameter.ParameterType), wantArgs.Args.Generate(parameter.Name)); } var emit = wantArgs.EndArgs().BeginBody(); emit = emit.Override(emit.Methods.Import(method)); emit = EmitFactoryCode( emit, entry, method.ReturnType, !forceNonNullResult(method)); classCode = emit.Ret().EndBody(); } return(classCode.EndClass()); }
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data) { var args = context.Method() .Static .Returning(context.Types.Object) .Named(methodName) .BeginArgs(); Def<Args> tokenId = args.Args.Generate("token"); Def<Args> oldValue = args.Args.Generate("oldValue"); Def<Args> newValue = args.Args.Generate("newValue"); Def<Args> ctx = args.Args.Generate("rootContext"); Def<Args> stackLookback = args.Args.Generate("startLookback"); var emit = args .Argument(context.Types.Int32, tokenId) .Argument(context.Types.Object, oldValue) .Argument(context.Types.Object, newValue) .Argument(context.Types.Object, ctx) .Argument(context.Types.Import(typeof(IStackLookback<Msg>)), stackLookback) .EndArgs() .BeginBody(); BuildBody( emit, data, tokenId.GetRef(), oldValue.GetRef(), newValue.GetRef(), ctx.GetRef(), stackLookback.GetRef()); return emit.EndBody(); }
public VBClassFormatter(ClassSyntax syntax) { _syntax = syntax; }
private ClassSyntax Build_Ctor(ClassSyntax context) { var emit = context .Method() .Public.Instance .Returning(context.Types.Void) .Named(".ctor") .BeginArgs() .Do(args => { var type = context.Types.Import(typeof(CilGrammarSource)); var arg = args.Args.Generate(); args.Argument(type, arg); return(args); }) .EndArgs() .BeginBody(); // Call base constructor: // this: emit = emit .Ldarg(0) // this .Ldarg(1) // LanguageName .Call(emit.Methods.Import(typeof(LanguageBase).GetConstructor(new[] { typeof(CilGrammarSource) }))) ; emit .Ldarg(0) .Ldc_I4(data.IsDeterministic ? 1 : 0) .Stfld(LanguageBase.Fields.isDeterministic); return(emit // Init grammar .Ldarg(0) .Call(emit.Methods.Method( _ => _ .StartSignature .Returning(emit.Types.Import(typeof(Grammar))) .DecaringType(declaringTypeRef) .Named(CreateGrammarMethodName) .BeginArgs() .EndArgs() )) .Stfld(LanguageBase.Fields.grammar) // Init state->token table .Ldarg(0) .Call(emit.Methods.Method( _ => _ .StartSignature .Returning(emit.Types.Import(typeof(int[]))) .DecaringType(declaringTypeRef) .Named(CreateStateToSymbolMethodName) .BeginArgs() .EndArgs() )) .Stfld(LanguageBase.Fields.stateToSymbol) // Init parser action conflicts table .Ldarg(0) .Call(emit.Methods.Method( _ => _ .StartSignature .Returning(emit.Types.Import(typeof(int[]))) .DecaringType(declaringTypeRef) .Named(CreateParserActionConflictsMethodName) .BeginArgs() .EndArgs() )) .Stfld(LanguageBase.Fields.parserConflictActions) // Init token complexity table .Ldarg(0) .Call(emit.Methods.Method( _ => _ .StartSignature .Returning(emit.Types.Import(typeof(int[]))) .DecaringType(declaringTypeRef) .Named(CreateTokenComplexityTableMethodName) .BeginArgs() .EndArgs() )) .Stfld(LanguageBase.Fields.tokenComplexity) // Init grammarAction field .Ldarg(0) .LdMethodDelegate( declaringTypeRef, RuleActionMethodName, typeof(ProductionActionDelegate)) .Stfld(LanguageBase.Fields.grammarAction) // Init grammarAction field .Ldarg(0) .LdMethodDelegate( declaringTypeRef, MergeActionMethodName, typeof(MergeDelegate)) .Stfld(LanguageBase.Fields.merge) // Init tokenIdentities .Ldarg(0) .Call(emit .Methods.Method( _ => _ .StartSignature .Returning(emit.Types.Import(LanguageBase.Fields.tokenKeyToId.FieldType)) .DecaringType(declaringTypeRef) .Named(CreateTokenKeyToIdMethodName) .BeginArgs() .EndArgs())) .Stfld(LanguageBase.Fields.tokenKeyToId) // Init scan field .Ldarg(0) .LdMethodDelegate( declaringTypeRef, ConditionMethods.GetMethodName(0), typeof(Scan1Delegate)) .Stfld(LanguageBase.Fields.scan1) // Init termFactory field .Ldarg(0) .LdMethodDelegate( declaringTypeRef, TermFactoryMethodName, typeof(ScanActionDelegate)) .Stfld(LanguageBase.Fields.termFactory) // Init getParserAction field .Ldarg(0) .LdMethodDelegate( declaringTypeRef, GetParserActionMethodName, typeof(TransitionDelegate)) .Stfld(LanguageBase.Fields.getParserAction) // Init defaul context factory .Ldarg(0) .LdMethodDelegate( declaringTypeRef, CreateDefaultContextMethodName, typeof(Func <object>)) .Stfld(LanguageBase.Fields.createDefaultContext) .Ret() .EndBody()); }
public CSharpClassFormatter(ClassSyntax syntax) { _syntax = syntax; }
/// <summary> /// Foramts the visibility modifier for a c# class. /// </summary> /// <param name="syntax">The syntax to format.</param> /// <returns>A formatted string representing the syntax of the class.</returns> /// <remarks> /// The visibility of a class is part of the modifiers section of the /// decleration. The modifiers are defined as: /// </remarks> public List <SyntaxToken> FormatVisibility(ClassSyntax syntax) { return(FormatVisibility(syntax.GetVisibility())); }
/// <summary> /// Formats the inheritance modifier for a c# class. /// </summary> /// <param name="syntax">The syntax to format.</param> /// <returns>The formatted string representing the syntax of the class.</returns> /// <remarks> /// The inheritance of a class is part of the modifiers section of the /// decleration. The modifiers are defined as: /// </remarks> public SyntaxToken FormatInheritance(ClassSyntax syntax) { return(FormatInheritance(syntax.GetInheritance())); }
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data) { var args = context.Method() .Static .Returning(context.Types.Object) .Named(methodName) .BeginArgs(); Def<Args> ruleId = args.Args.Generate("ruleId"); Def<Args> ruleArgs = args.Args.Generate("ruleArgs"); Def<Args> argsStart = args.Args.Generate("argsStart"); Def<Args> ctx = args.Args.Generate("rootContext"); Def<Args> stackLookback = args.Args.Generate("startLookback"); var emit = args .Argument(context.Types.Int32, ruleId) .Argument(context.Types.Import(typeof(Msg[])), ruleArgs) .Argument(context.Types.Int32, argsStart) .Argument(context.Types.Object, ctx) .Argument(context.Types.Import(typeof(IStackLookback<Msg>)), stackLookback) .EndArgs() .BeginBody(); ruleId.Name = "ruleId"; ruleArgs.Name = "args"; argsStart.Name = "argsStart"; ctx.Name = "ctx"; stackLookback.Name = "stackLookback"; BuildBody( emit, data, ruleId.GetRef(), ruleArgs.GetRef(), argsStart.GetRef(), ctx.GetRef(), stackLookback.GetRef()); return emit.EndBody(); }
public ClassBinder(Binder containingScope, ClassSyntax @class) : base(containingScope) { }
private ClassSyntax BuildMethod_GrammarAction(ClassSyntax context) { var generator = new ProductionActionGenerator(); return(generator.BuildMethod(context, RuleActionMethodName, data)); }
private void BindClass(BoundType @class, ClassSyntax syntax) { _contextService.EnterClass(@class); foreach (var boundField in @class.FieldsInternal) { BindField(boundField, (FieldSyntax)boundField.Syntax); } foreach (var boundFunction in @class.FunctionsInternal) { _contextService.EnterScope(); BindFunction(boundFunction, (FunctionSyntax)boundFunction.Syntax); _contextService.ExitScope(); } @class.ConstructorsInternal.AddRange(syntax.Constructors.Select(BindConstructor).ToList()); _contextService.ExitClass(); }