//public static void RemoveAttributeIfExists(DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeFunction function) //{ // function.RemoveAttributeIfExists("Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers.CachingCallHandler"); //} public void SetAttribute(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeFunction function) { function.AddAttribute("Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers.CachingCallHandler", context.Strategy.StrategyId, false, String.Empty, expirationTime.Hours.ToString(), String.Empty, expirationTime.Minutes.ToString(), String.Empty, expirationTime.Seconds.ToString()); }
//public static void RemoveAttributeIfExists(DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeFunction function) //{ // function.RemoveAttributeIfExists("Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers.PerformanceCounterCallHandler"); //} public void SetAttribute(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeFunction function) { Dictionary <string, string> args = new Dictionary <string, string>(); args.Add(CandleCodeElement.EmptyAttributeNameSig + "0", "\"" + categoryName + "\""); args.Add(CandleCodeElement.EmptyAttributeNameSig + "1", "\"" + instanceName + "\""); if (incrementAverageCallDuration) { args.Add("IncrementAverageCallDuration", "true"); } if (incrementCallsPerSecond) { args.Add("IncrementCallsPerSecond", "true"); } if (incrementExceptionsPerSecond) { args.Add("IncrementExceptionsPerSecond", "true"); } if (incrementNumberOfCalls) { args.Add("IncrementNumberOfCalls", "true"); } if (incrementTotalExceptions) { args.Add("IncrementTotalExceptions", "true"); } if (useTotalCounter) { args.Add("UseTotalCounter", "true"); } function.AddAttribute("Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers.PerformanceCounterCallHandler", context.Strategy.StrategyId, false, args); }
public void SetAttribute(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeFunction function) { function.AddAttribute("Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers.LogCallHandler", context.Strategy.StrategyId, false, PrepareLogAttribute(function.ToString())); }
/// <summary> /// Applique les stratégies d'injection de code /// </summary> /// <param name="projectItem">The project item.</param> /// <param name="element">The element.</param> /// <param name="context">The context.</param> public static void ApplyCodeInjectionStrategies(ProjectItem projectItem, ICustomizableElement element, GenerationContext context) { ILogger logger = ServiceLocator.Instance.GetService <ILogger>(); if (logger != null) { logger.BeginStep("Injection code generation", LogType.Info); logger.Write("Injection code generation", String.Concat("Current element is ", element.Name, " (id=", element.Id, ")"), LogType.Debug); } EnvDTE80.FileCodeModel2 fcm = null; if (projectItem != null) { fcm = projectItem.FileCodeModel as EnvDTE80.FileCodeModel2; if (fcm == null) { if (logger != null) { logger.Write("Injection code generation", "No code model associated with this element - exit", LogType.Debug); logger.EndStep(); } return; } //fcm.BeginBatch(); } try { CodeInjectionContext gc = new CodeInjectionContext(context); List <StrategyBase> strategies = new List <StrategyBase>(); // Execution des stratégies foreach (StrategyBase strategy in element.GetStrategies(false)) { if (!(strategy is IStrategyCodeInjector)) { continue; } if (logger != null) { logger.Write("Injection code generation", String.Concat("Strategy ", strategy.StrategyId), LogType.Debug); } if (context.SelectedStrategies != null && (context.SelectedStrategies != null && !context.SelectedStrategies.Contains(strategy))) { if (logger != null) { logger.Write("Injection code generation", "Strategy skipped because this is not a selected strategy", LogType.Debug); } continue; } strategies.Add(strategy); } // Tri dans l'ordre d'exécution // strategies.Sort(delegate(IStrategyCodeInjector a, IStrategyCodeInjector b) { return a.ExecutionOrder.CompareTo(b.ExecutionOrder); }); foreach (StrategyBase injector in strategies) { if (logger != null) { logger.BeginStep(String.Concat("Run strategy ", injector.DisplayName, " id=", injector.StrategyId), LogType.Debug); } gc.CurrentElement = element; gc.Strategy = (IStrategyCodeInjector)injector; try { if (gc.GenerationContext.GenerationPass == GenerationPass.MetaModelUpdate) { ((IStrategyCodeInjector)injector).OnMetaModelUpdate(gc); } else { CodeModelWalker walker = new CodeModelWalker(new CodeInjectorVisitor(gc)); walker.Traverse(fcm); } } catch (Exception ex) { if (logger != null) { logger.WriteError(injector.DisplayName, "Code Injection error", ex); } } finally { gc.Strategy = null; gc.CurrentElement = null; if (logger != null) { logger.EndStep(); } } } } finally { if (fcm != null) { // fcm.EndBatch(); // fcm.Synchronize(); } } if (logger != null) { logger.EndStep(); } }
/// <summary> /// Initializes a new instance of the <see cref="CodeInjectorVisitor"/> class. /// </summary> /// <param name="context">The context.</param> public CodeInjectorVisitor(CodeInjectionContext context) { _context = context; _injector = context.Strategy; }
void IStrategyCodeInjector.OnGenerateClass(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeClass clazz) { }
void IStrategyCodeInjector.OnMetaModelUpdate(CodeInjectionContext context) { // Reference pour le ServiceLocator if (context.CurrentElement is Layer) { Layer layer = context.CurrentElement as Layer; foreach (ClassImplementation clazz in layer.Classes) { foreach (ClassUsesOperations service in ClassUsesOperations.GetLinksToServicesUsed(clazz)) { if (!context.GenerationContext.Mode.CheckConfigurationMode(service.ConfigurationMode) || service.TargetService is ExternalServiceContract) { continue; } foreach (Implementation impl in Implementation.GetLinksToImplementations((ServiceContract)service.TargetService)) { if (context.GenerationContext.Mode.CheckConfigurationMode(impl.ConfigurationMode)) { if (CheckAllHandler(impl.ClassImplementation, impl.ClassImplementation.Layer)) { layer.AddReferenceToService(entLibId, "EnterpriseLibrary", new VersionInfo(3, 1, 0, 0), "Microsoft.Practices.EnterpriseLibrary.PolicyInjection"); return; } } } } } } if (context.CurrentElement is ClassImplementation) { ClassImplementation clazz = context.CurrentElement as ClassImplementation; if (clazz.Contract == null) { return; } bool flag = false; foreach (Operation op in clazz.Contract.Operations) { IPIABHandler handler = CheckHandler <LogCallHandler>(LogCallHandlerProperty, op, clazz); if (handler != null && handler.Enabled) { ((ClassImplementation)context.CurrentElement).Layer.AddReferenceToService(entLibId, "EnterpriseLibrary", new VersionInfo(3, 1, 0, 0), "Microsoft.Practices.EnterpriseLibrary.Logging", ReferenceScope.Runtime, "*"); flag = true; } handler = CheckHandler <CacheCallHandler>(CacheCallHandlerProperty, op, clazz); if (handler != null && handler.Enabled) { ((ClassImplementation)context.CurrentElement).Layer.AddReferenceToService(entLibId, "EnterpriseLibrary", new VersionInfo(3, 1, 0, 0), "Microsoft.Practices.EnterpriseLibrary.Caching", ReferenceScope.Runtime, "*"); flag = true; } // PerformanceCounterCallHandler handler = CheckHandler <PerformanceCounterCallHandler>(PerformanceCounterCallHandlerProperty, op, clazz); if (handler != null && handler.Enabled) { ((ClassImplementation)context.CurrentElement).Layer.AddReferenceToService(entLibId, "EnterpriseLibrary", new VersionInfo(3, 1, 0, 0), "Microsoft.Practices.EnterpriseLibrary.Common.Instrumentation", ReferenceScope.Runtime, "*"); flag = true; } } if (flag) { ((ClassImplementation)context.CurrentElement).Layer.AddReferenceToService(entLibId, "EnterpriseLibrary", new VersionInfo(3, 1, 0, 0), "Microsoft.Practices.EnterpriseLibrary.PolicyInjection"); ((ClassImplementation)context.CurrentElement).Layer.AddReferenceToService(entLibId, "EnterpriseLibrary", new VersionInfo(3, 1, 0, 0), "Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers", ReferenceScope.Runtime | ReferenceScope.Compilation, "*"); } } }
void IStrategyCodeInjector.OnGenerateVariable(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeVariable variable) { }
string[] IStrategyCodeInjector.OnGenerateUsing(CodeInjectionContext context) { return(null); }
void IStrategyCodeInjector.OnGenerateStruct(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeStruct structure) { }
void IStrategyCodeInjector.OnGenerateProperty(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeProperty prop) { }
void IStrategyCodeInjector.OnGenerateParameter(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeParameter parm) { }
void IStrategyCodeInjector.OnGenerateInterface(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeInterface interf) { }
void IStrategyCodeInjector.OnGenerateFunction(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeFunction function) { // Service factory if (context.CurrentElement is Layer) { // On part du principe que le template du servicelocator à généré une classe nommée ServiceLocator et // une méthode par création d'instance dont le nom commence par CreateInstanceOfxxxxxx if (function.Parent.Name == "ServiceLocatorBase" && function.Name.StartsWith("CreateInstanceOf")) { string currentName = function.Name.Substring("CreateInstanceOf".Length); foreach (ClassImplementation clazz in ((Layer)context.CurrentElement).Classes) { foreach (ClassUsesOperations service in ClassUsesOperations.GetLinksToServicesUsed(clazz)) { if (!context.GenerationContext.Mode.CheckConfigurationMode(service.ConfigurationMode) || service.TargetService is ExternalServiceContract) { continue; } ServiceContract contract = service.TargetService as ServiceContract; if (contract == null) { continue; } foreach (Implementation impl in Implementation.GetLinksToImplementations(contract)) { if (context.GenerationContext.Mode.CheckConfigurationMode(impl.ConfigurationMode) && impl.ClassImplementation.Name == currentName) { if (impl.ClassImplementation.Contract != null) { foreach (Operation op in impl.ClassImplementation.Contract.Operations) { if (CheckAllHandler(op, impl.ClassImplementation)) { function.ReplaceBody( @" string path = ConfigurationManager.AppSettings[key]; Type t = Assembly.Load(path).GetType(""" + impl.ClassImplementation.FullName + @"""); PropertyInfo p = typeof(Microsoft.Practices.EnterpriseLibrary.PolicyInjection.PolicyInjection).GetProperty(""DefaultPolicyInjector"", BindingFlags.Static | BindingFlags.NonPublic); Microsoft.Practices.EnterpriseLibrary.PolicyInjection.PolicyInjector pi = (Microsoft.Practices.EnterpriseLibrary.PolicyInjection.PolicyInjector)p.GetValue(null, null); return (" + contract.FullName + ")pi.Create(t, typeof(" + contract.FullName + @")); "); return; } } } } } } } } } // Attribut if (context.CurrentElement is ClassImplementation) { ClassImplementation clazz = context.CurrentElement as ClassImplementation; if (clazz.Name + "Base" == function.Parent.Name || clazz.Name == function.Parent.Name) { Operation op = function.FindOperationFromContract(clazz.Contract); if (op != null) { // LogCallHandler IPIABHandler handler = CheckHandler <LogCallHandler>(LogCallHandlerProperty, op, clazz); if (handler != null && handler.Enabled) { handler.SetAttribute(context, function); } // CacheCallHandler handler = CheckHandler <CacheCallHandler>(CacheCallHandlerProperty, op, clazz); if (handler != null && handler.Enabled) { handler.SetAttribute(context, function); } // PerformanceCounterCallHandler handler = CheckHandler <PerformanceCounterCallHandler>(PerformanceCounterCallHandlerProperty, op, clazz); if (handler != null && handler.Enabled) { handler.SetAttribute(context, function); } } } } }
void IStrategyCodeInjector.OnGenerateEnum(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeEnum enumeration) { }