private string RenderStartOperation(EventModel model)
{
var operationName = GetEventOperationName(model);
var output = Template_LOGGER_METHOD_TRACKOPERATIONSTART_DECLARATION;
var requestName = "";
var requestArgumentName = GetRequestNameArgument(model);
if (requestArgumentName != null)
{
requestName = CreateDictionaryKeyValue(requestArgumentName).Value;
}
else
{
requestName = $"\"{operationName}\"";
}
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_NAME, operationName);
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_REQUESTNAME, requestName);
var arguments = new EventArgumentsListBuilder("", arg => RenderDictionaryKeyValueAdd(arg, operationName), "\r\n ");
foreach (var argumentModel in model.GetAllArgumentsExpanded(directArgumentAssignments: false))
{
arguments.Append(argumentModel);
}
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_PROPERTIES_DECLARATION, arguments.ToString());
return(output);
}
protected string Render(EventModel model)
{
if (!model.HasComplexArguments)
{
return("");
}
var outputNonEventMethod = EventSourceNonEventMethodTemplate.Template_NON_EVENT_METHOD;
outputNonEventMethod = outputNonEventMethod.Replace(EventSourceNonEventMethodTemplate.Variable_EVENT_NAME, model.Name);
var methodArgumentsDeclarationBuilder = new EventArgumentsListBuilder(
RenderNonEventMethodArgument, EventSourceNonEventMethodTemplate.Template_NONEVENT_METHOD_ARGUMENT_DELIMITER);
var assignmentArgumentsBuilder = new EventArgumentsListBuilder(
RenderAssignment, EventSourceNonEventMethodTemplate.Template_NON_EVENT_ASSIGNMENT_ARGUMENT_DELIMITER);
foreach (var argument in model.GetAllArguments())
{
methodArgumentsDeclarationBuilder.Append(argument);
}
foreach (var argument in model.GetAllArgumentsExpanded())
{
assignmentArgumentsBuilder.Append(argument);
}
outputNonEventMethod = outputNonEventMethod.Replace(EventSourceNonEventMethodTemplate.Variable_NON_EVENT_METHOD_ARGUMENTS, methodArgumentsDeclarationBuilder.ToString());
outputNonEventMethod = outputNonEventMethod.Replace(EventSourceNonEventMethodTemplate.Variable_NON_EVENT_ASSIGNMENT_ARGUMENTS, assignmentArgumentsBuilder.ToString());
return(outputNonEventMethod);
}
private string RenderTrackException(EventModel model)
{
var exceptionName = GetExceptionArgumentName(model)?.Name;
var propertyEventName = "Name";
var output = Template_LOGGER_METHOD_TRACKEXCEPTION_DECLARATION;
output = output.Replace(Variable_LOGGER_METHOD_TRACKEXCEPTION_NAME, model.Name);
output = output.Replace(Variable_LOGGER_METHOD_TRACKEXCEPTION_EXCEPTION_NAME, exceptionName);
var arguments = new EventArgumentsListBuilder("", RenderDictionaryKeyValue, ",\r\n ");
var eventArgumentModels = model.GetAllArgumentsExpanded(directArgumentAssignments: false).ToArray();
foreach (var argumentModel in eventArgumentModels)
{
if (argumentModel.Name == propertyEventName)
{
propertyEventName = null;
}
arguments.Append(argumentModel);
}
var nameIndex = 1;
while (eventArgumentModels.Any(a => a.Name == propertyEventName))
{
propertyEventName = $"Name{nameIndex}";
nameIndex++;
}
output = output.Replace(Variable_LOGGER_METHOD_TRACKEXCEPTION_EVENTNAME, propertyEventName);
output = output.Replace(Variable_LOGGER_METHOD_TRACKEVENT_PROPERTIES_DECLARATION, arguments.ToString());
return(output);
}
private string RenderMethod(Project project, ProjectItem <LoggerModel> loggerProjectItem, EventSourceModel eventSourceModel, EventModel model)
{
var eventName = model.Name;
var output = LoggerImplementationEventMethodTemplate.Template_LOGGER_METHOD;
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_NAME, eventName);
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_EVENTSOURCE_CLASS_NAME, eventSourceModel.ClassName);
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_RETURNTYPE, model.ReturnType ?? "void");
var methodArguments = new EventArgumentsListBuilder(
RenderMethodArgument, LoggerImplementationEventMethodTemplate.Template_LOGGER_IMPLICIT_ARGUMENTS_METHOD_DECLARATION_DELIMITER);
foreach (var argument in model.GetAllNonImplicitArguments())
{
methodArguments.Append(argument);
}
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_ARGUMENTS, methodArguments.ToString());
var methodImplementation = new StringBuilder();
var renderers = new ILoggerImplementationMethodRenderer[]
{
new LoggerImplementationMethodCallEventSourceEventRenderer(),
}.Union(project.GetExtensions <ILoggerImplementationMethodRenderer>(eventSourceModel.Settings?.Modules ?? new string[0])).ToArray();
foreach (var renderer in renderers)
{
PassAlongLoggers(renderer as IWithLogging);
methodImplementation.Append(renderer.Render(project, loggerProjectItem, model));
}
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_IMPLEMENTATION, methodImplementation.ToString());
return(output);
}
protected string Render(EventModel model)
{
var outputEventMethod = EventSourceEventMethodTemplate.Template_EVENT_METHOD;
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_NAME, model.Name);
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_ID, model.Id.ToString());
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_LEVEL, model.Level.ToString());
var keywords = new ListBuilder("", " | ", "");
foreach (var keyword in model.Keywords ?? new KeywordModel[] { })
{
keywords.Append($"Keywords.{keyword.Name}");
}
var keywordsDeclaration = (keywords.Length > 0) ? $", Keywords = {keywords}" : "";
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_KEYWORDS_DECLARATION, keywordsDeclaration);
var opCode = (string)null;
if (model.OpCode != null)
{
opCode = model.OpCode.ToString();
}
var opCodeDeclaration = (opCode != null) ? $", Opcode = EventOpcode.{opCode}" : "";
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_OPCODE_DECLARATION, opCodeDeclaration);
var eventTask = (string)null;
if (model.Task != null)
{
eventTask = model.Task.Name;
}
var eventTaskDeclaration = (eventTask != null) ? $", Task = Tasks.{eventTask}" : "";
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_TASK_DECLARATION, eventTaskDeclaration);
var eventMethodArgumentsDeclarationBuilder = new EventArgumentsListBuilder(
RenderEventMethodArgument, EventSourceEventMethodTemplate.Template_EVENT_METHOD_ARGUMENT_DELIMITER);
var writeEventMethodCallArgument = new EventArgumentsListBuilder(
(arg) => RenderWriteEventMethodCallArgument(arg), EventSourceEventMethodTemplate.Template_EVENT_METHOD_CALL_ARGUMENT_DELIMITER);
writeEventMethodCallArgument.Append($"{model.Name}EventId");
foreach (var argument in model.GetAllArgumentsExpanded())
{
eventMethodArgumentsDeclarationBuilder.Append(argument);
writeEventMethodCallArgument.Append(argument);
}
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_METHOD_ACCESS, model.HasComplexArguments ? "private" : "public");
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_METHOD_ARGUMENTS, eventMethodArgumentsDeclarationBuilder.ToString());
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_WRITEEVENT_CALL_ARGUMENTS, writeEventMethodCallArgument.ToString());
outputEventMethod = outputEventMethod.Replace(EventSourceEventMethodTemplate.Variable_EVENT_MESSAGE_FORMATTER, model.MessageFormatter);
return(outputEventMethod);
}
private string RenderStartScopedOperation(EventModel model)
{
var operationName = GetEventOperationName(model);
var output = Template_LOGGER_METHOD_TRACKSCOPEDOPERATIONSTART_DECLARATION;
var requestName = "";
var requestArgumentName = GetRequestNameArgument(model);
if (requestArgumentName != null)
{
requestName = CreateDictionaryKeyValue(requestArgumentName).Value;
}
else
{
requestName = $"\"{operationName}\"";
}
var telemetryType = "Request";
if (model.Name.Matches(@"(call|send)", StringComparison.InvariantCultureIgnoreCase, false))
{
telemetryType = "Dependency";
}
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_NAME, operationName);
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_REQUESTNAME, requestName);
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_TELEMETRYTYPE, telemetryType);
output = output.Replace(Variable_LOGGER_METHOD_TRACKSCOPEDOPERATIONSTOP_METHOD_NAME, model.CorrelatesTo.Name);
var arguments = new EventArgumentsListBuilder("", arg => RenderDictionaryKeyValueAdd(arg, operationName), "\r\n ");
foreach (var argumentModel in model.GetAllArgumentsExpanded(directArgumentAssignments: false))
{
arguments.Append(argumentModel);
}
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_PROPERTIES_DECLARATION, arguments.ToString());
var stopOperationArguments = new EventArgumentsListBuilder("", arg => $"{arg.Name}", ",");
foreach (var argumentModel in model.GetAllNonImplicitArguments())
{
stopOperationArguments.Append(argumentModel);
}
output = output.Replace(Variable_LOGGER_METHOD_TRACKOPERATION_METHOD_ARGUMENTS_ASSIGNMENT, stopOperationArguments.ToString());
return(output);
}
private string RenderTrackEvent(EventModel model)
{
var output = Template_LOGGER_METHOD_TRACKEVENT_DECLARATION;
output = output.Replace(Variable_LOGGER_METHOD_TRACKEVENT_NAME, model.Name);
var arguments = new EventArgumentsListBuilder("", RenderDictionaryKeyValue, ",\r\n ");
foreach (var argumentModel in model.GetAllArgumentsExpanded(directArgumentAssignments: false))
{
arguments.Append(argumentModel);
}
output = output.Replace(Variable_LOGGER_METHOD_TRACKEVENT_PROPERTIES_DECLARATION, arguments.ToString());
return(output);
}
public string Render(Project project, ProjectItem <LoggerModel> loggerProjectItem, EventModel model)
{
if (loggerProjectItem.ItemType != ProjectItemType.LoggerImplementation)
{
LogError($"{loggerProjectItem.Name} should be of ItemType {nameof(ProjectItemType.LoggerImplementation)} set but found {loggerProjectItem.ItemType}");
return("");
}
var loggerModel = loggerProjectItem.Content;
if (loggerModel == null)
{
LogError($"{loggerProjectItem?.Name ?? nameof(loggerProjectItem)} should have content of type {typeof(LoggerModel).Name}, but found {loggerProjectItem?.GetType().Name ?? "null"}");
return("");
}
var eventSourceModel = loggerModel.EventSource;
if (eventSourceModel == null)
{
LogError($"{loggerProjectItem?.Name ?? nameof(loggerProjectItem)} should have content of type {typeof(LoggerModel).Name} with property EventSource set, but found {loggerModel.EventSource?.Name ?? "null"}");
return("");
}
var output = LoggerImplementationMethodCallEventSourceEventTemplate.Template_LOGGER_METHOD_CALL_EVENTSOURCE_EVENT;
output = output.Replace(LoggerImplementationMethodCallEventSourceEventTemplate.Variable_EVENTSOURCE_CLASS_NAME, eventSourceModel.ClassName);
output = output.Replace(LoggerImplementationMethodCallEventSourceEventTemplate.Variable_LOGGER_METHOD_NAME, model.Name);
var callArguments = new EventArgumentsListBuilder(
RenderEventSourceEventMethodCallArgument, LoggerImplementationMethodCallEventSourceEventTemplate.Template_LOGGER_CALL_ARGUMENTS_DELIMITER);
foreach (var argument in model.GetAllArguments())
{
callArguments.Append(argument);
}
output = output.Replace(LoggerImplementationMethodCallEventSourceEventTemplate.Variable_LOGGER_METHOD_IMPLEMENTATION_CALL_ARGUMENTS, callArguments.ToString());
return(output);
}
public void Render(Project project, ProjectItem <LoggerModel> model)
{
if (model.ItemType != ProjectItemType.LoggerImplementation)
{
LogError($"{model.Name} should be of ItemType {nameof(ProjectItemType.LoggerImplementation)} set but found {model.ItemType}");
return;
}
var loggerModel = model.Content;
if (loggerModel == null)
{
LogError($"{model.Name} should have a content of type {typeof(EventSourceModel).Name} set but found {model.Content?.GetType().Name ?? "null"}");
return;
}
var eventSourceProjectItem = model.DependentUpon as ProjectItem <EventSourceModel>;
var eventSourceModel = eventSourceProjectItem?.Content;
if (eventSourceModel == null)
{
LogError($"{model.Name} should be DependentUpon a ProjectItem<EventSourceModel>, but found {model.DependentUpon?.GetType().Name ?? "null"}");
return;
}
var output = LoggerImplementationTemplate.Template_LOGGER_CLASS_DECLARATION;
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_SOURCE_FILE_NAME, loggerModel.SourceFileName);
output = output.Replace(LoggerImplementationTemplate.Variable_NAMESPACE_DECLARATION, loggerModel.LoggerNamespace);
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_NAME, loggerModel.Name);
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_CLASS_NAME, loggerModel.ClassName);
output = output.Replace(LoggerImplementationTemplate.Variable_EVENTSOURCE_NAMESPACE, eventSourceModel.Namespace);
var memberDeclarations = new EventArgumentsListBuilder(
RenderPrivateDeclaration, LoggerImplementationTemplate.Template_LOGGER_IMPLICIT_ARGUMENTS_MEMBER_DECLARATION_DELIMITER);
var constructorMemberAssignments = new EventArgumentsListBuilder(
RenderPrivateAssignment, LoggerImplementationTemplate.Variable_LOGGER_IMPLICIT_ARGUMENTS_MEMBER_ASSIGNMENT_DELIMITER);
var constructorArguments = new EventArgumentsListBuilder(
RenderMethodArgument, LoggerImplementationTemplate.Variable_LOGGER_IMPLICIT_ARGUMENTS_METHOD_CONSTRUCTOR_DELIMITER);
foreach (var argument in loggerModel.ImplicitArguments)
{
memberDeclarations.Append(argument);
constructorArguments.Append(argument);
constructorMemberAssignments.Append(argument);
}
var usings = new StringBuilder();
var usingRenderers = new ILoggerImplementationUsingRenderer[]
{
}.Union(project.GetExtensions <ILoggerImplementationUsingRenderer>(eventSourceModel.Settings?.Modules ?? new string[0])).ToArray();
foreach (var renderer in usingRenderers)
{
PassAlongLoggers(renderer as IWithLogging);
usings.Append(renderer.Render(project, model));
}
var useReferencedHelpers = loggerModel.EventSource.Settings.UseReferencedHelpers
? "using FG.Diagnostics.AutoLogger.Model;\r\n"
: "";
var memberRenderers = new ILoggerImplementationMembersRenderer[]
{
}.Union(project.GetExtensions <ILoggerImplementationMembersRenderer>(eventSourceModel.Settings?.Modules ?? new string[0])).ToArray();
foreach (var renderer in memberRenderers)
{
PassAlongLoggers(renderer as IWithLogging);
memberDeclarations.Append(renderer.Render(project, model));
}
var constructorRenderers = new ILoggerImplementationConstructorRenderer[]
{
}.Union(project.GetExtensions <ILoggerImplementationConstructorRenderer>(eventSourceModel.Settings?.Modules ?? new string[0])).ToArray();
foreach (var renderer in constructorRenderers)
{
PassAlongLoggers(renderer as IWithLogging);
constructorMemberAssignments.Append(renderer.Render(project, model));
}
var scopeWrappers = !loggerModel.EventSource.Settings.UseReferencedHelpers
? LoggerImplementationTemplate.Template_LOGGER_IMPLEMENTATION_SCOPE_WRAPPERS
: "";
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_IMPLICIT_USING_DECLARATION, usings.ToString());
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_IMPLICIT_ARGUMENTS_MEMBER_DECLARATION, memberDeclarations.ToString());
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_IMPLICIT_ARGUMENTS_MEMBER_ASSIGNMENT, constructorMemberAssignments.ToString());
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_IMPLICIT_ARGUMENTS_CONSTRUCTOR_DECLARATION, constructorArguments.ToString());
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_USING_AUTOLOGGER_MODEL, useReferencedHelpers);
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_IMPLEMENTATION_SCOPE_WRAPPERS, scopeWrappers);
var logger = new StringBuilder();
var loggerEventRenderers = new ILoggerImplementationEventRenderer[]
{
new LoggerImplementationEventMethodRenderer(),
}.Union(project.GetExtensions <ILoggerImplementationEventRenderer>(eventSourceModel.Settings?.Modules ?? new string[0])).ToArray();
foreach (var loggerEvent in loggerModel.Events)
{
foreach (var renderer in loggerEventRenderers)
{
PassAlongLoggers(renderer as IWithLogging);
var eventRender = renderer.Render(project, model, loggerEvent);
logger.AppendLine(eventRender);
}
}
output = output.Replace(LoggerImplementationTemplate.Variable_LOGGER_IMPLEMENTATION, logger.ToString());
model.Output = output;
}
public string Render(EventModel model, int index, EventSourcePrototype eventSource)
{
var outputEventMethod = Template.Template_EVENT_METHOD;
outputEventMethod = outputEventMethod.Replace(Template.Variable_EVENT_NAME, model.Name);
outputEventMethod = outputEventMethod.Replace(Template.Variable_EVENT_ID, index.ToString());
outputEventMethod = outputEventMethod.Replace(Template.Variable_EVENT_LEVEL, model.Level.ToString());
var outputNonEventMethod = Template.Template_NON_EVENT_METHOD;
outputNonEventMethod = outputNonEventMethod.Replace(Template.Variable_EVENT_NAME, model.Name);
var keywords = new ListBuilder("", " | ", "");
foreach (var keyword in model.Keywords ?? new KeywordModel[] { })
{
keywords.Append($"Keywords.{keyword.Name}");
}
var keywordsDeclaration = (keywords.Length > 0) ? $", Keywords = {keywords}" : "";
outputEventMethod = outputEventMethod.Replace(Template.Variable_EVENT_KEYWORDS_DECLARATION, keywordsDeclaration);
var next = 0;
var messageFormatBuilder = new ListBuilder($"{model.Name.GetHumanReadable()}", " ", " ");
var eventMethodArgumentsDeclarationBuilder = new EventArgumentsListBuilder((arg) => arg.RenderMethodArgument(), Template.Template_EVENT_METHOD_ARGUMENT_DELIMITER);
var nonEventMethodArgumentsDeclarationBuilder = new EventArgumentsListBuilder((arg) => arg.RenderMethodArgument(), Template.Template_NONEVENT_METHOD_ARGUMENT_DELIMITER);
var callArgumentsBuilder = new EventArgumentsListBuilder((arg) => arg.RenderWriteEventMethodCallArgument(), Template.Template_EVENT_METHOD_CALL_ARGUMENT_DELIMITER);
var assignmentArgumentsBuilder = new EventArgumentsListBuilder((arg) => (arg as EventSourceEventCustomArgument)?.Assignment.Replace(@"$this", arg.Name) ?? arg.Name, Template.Template_NON_EVENT_ASSIGNMENT_ARGUMENT_DELIMITER);
var hasComplexArguments = false;
var allArguments = new List <EventArgumentModel>();
var messageArgumentsStart = 0;
var messageArgumentsCount = 0;
if (model.ImplicitArguments != null && model.ImplicitArguments.Length > 0)
{
allArguments.AddRange(model.ImplicitArguments);
messageArgumentsStart += model.ImplicitArguments.Length;
}
allArguments.AddRange(model.Arguments);
var messageArgument = allArguments.FirstOrDefault(arg => model.Name.Equals("message", StringComparison.InvariantCultureIgnoreCase));
var messageArgumentIndex = messageArgument != null?allArguments.IndexOf(messageArgument) : -1;
var flatIndex = 0;
foreach (var argument in allArguments)
{
argument.SetCLRType(eventSource);
var methodArgument = "";
if (argument is EventSourceEventCustomArgument)
{
methodArgument = argument.RenderMethodArgument();
if (flatIndex >= messageArgumentsStart)
{
messageFormatBuilder.Append($"{{{next}}}");
}
var customArgument = argument as EventSourceEventCustomArgument;
assignmentArgumentsBuilder.Append(customArgument);
eventSource.AddKnownExtensions(customArgument, customArgument.CLRType);
var originalCLRType = customArgument.CLRType;
customArgument.CLRType = customArgument.AssignedCLRType ?? customArgument.CLRType;
eventMethodArgumentsDeclarationBuilder.Append(customArgument);
callArgumentsBuilder.Append(customArgument);
customArgument.CLRType = originalCLRType;
next += 1;
}
else if (!argument.IsComplexType())
{
// Just render the argument as it is
methodArgument = argument.RenderMethodArgument();
if (flatIndex >= messageArgumentsStart)
{
messageFormatBuilder.Append($"{{{next}}}");
}
assignmentArgumentsBuilder.Append(argument);
eventMethodArgumentsDeclarationBuilder.Append(argument);
callArgumentsBuilder.Append(argument);
next += 1;
}
else
{
// Split the argument according to a template
hasComplexArguments = true;
var template = eventSource.TypeTemplates.GeTypeTemplate(argument.Type);
if (template != null)
{
methodArgument = argument.RenderMethodArgument();
foreach (var customArgument in template.Arguments)
{
if (flatIndex >= messageArgumentsStart)
{
messageFormatBuilder.Append($"{{{next}}}");
}
customArgument.SetCLRType(eventSource);
assignmentArgumentsBuilder.Append(customArgument);
eventMethodArgumentsDeclarationBuilder.Append(customArgument);
callArgumentsBuilder.Append(customArgument);
next += 1;
}
}
else
{
// Render it as ToString()
methodArgument = argument.RenderMethodPureArgument();
if (flatIndex >= messageArgumentsStart)
{
messageFormatBuilder.Append($"{{{next}}}");
}
assignmentArgumentsBuilder.Append($"{argument.Name}.ToString()");
eventMethodArgumentsDeclarationBuilder.Append(argument.RenderMethodArgument(useSimpleTypesOnly: true));
callArgumentsBuilder.Append(argument);
next += 1;
}
}
nonEventMethodArgumentsDeclarationBuilder.Append(methodArgument);
flatIndex++;
}
outputNonEventMethod = outputNonEventMethod.Replace(Template.Variable_NON_EVENT_METHOD_ARGUMENTS, nonEventMethodArgumentsDeclarationBuilder.ToString());
outputNonEventMethod = outputNonEventMethod.Replace(Template.Variable_NON_EVENT_ASSIGNMENT_ARGUMENTS, assignmentArgumentsBuilder.ToString());
outputEventMethod = outputEventMethod.Replace(Template.Variable_EVENT_METHOD_ACCESS, hasComplexArguments ? "private" : "public");
outputEventMethod = outputEventMethod.Replace(Template.Variable_EVENT_METHOD_ARGUMENTS, eventMethodArgumentsDeclarationBuilder.ToString());
outputEventMethod = outputEventMethod.Replace(Template.Variable_WRITEEVENT_CALL_ARGUMENTS, callArgumentsBuilder.ToString());
var nonEventMethodDeclaration = hasComplexArguments ? outputNonEventMethod : "";
outputEventMethod = outputEventMethod.Replace(Template.Variable_NON_EVENT_METHOD_DECLARATION, nonEventMethodDeclaration);
var formatter = $"{{{next - 1}}}";
if (model.MessageFormatter != null)
{
formatter = model.MessageFormatter;
}
else if (messageArgumentIndex >= 0)
{
formatter = $"{{{messageArgumentIndex}}}";
}
else
{
formatter = messageFormatBuilder.ToString();
}
outputEventMethod = outputEventMethod.Replace(Template.Variable_EVENT_MESSAGE_FORMATTER, formatter);
//var formatter = messageFormatBuilder.ToString();
//output = output.Replace(Template_EVENT_METHOD_ARGUMENTS, MessageFormatter ?? "{7}");
return(outputEventMethod);
}
public string Render(Project project, ProjectItem <LoggerModel> loggerProjectItem, EventModel model)
{
if (loggerProjectItem.ItemType != ProjectItemType.LoggerImplementation)
{
LogError($"{loggerProjectItem.Name} should be of ItemType {nameof(ProjectItemType.LoggerImplementation)} set but found {loggerProjectItem.ItemType}");
return("");
}
var loggerModel = loggerProjectItem.Content;
if (loggerModel == null)
{
LogError($"{loggerProjectItem?.Name ?? nameof(loggerProjectItem)} should have content of type {typeof(LoggerModel).Name}, but found {loggerProjectItem?.GetType().Name ?? "null"}");
return("");
}
var eventSourceModel = loggerModel.EventSource;
if (eventSourceModel == null)
{
LogError($"{loggerProjectItem?.Name ?? nameof(loggerProjectItem)} should have content of type {typeof(LoggerModel).Name} with property EventSource set, but found {loggerModel.EventSource?.Name ?? "null"}");
return("");
}
var eventName = model.Name;
if ((model.ReturnType == "System.IDisposable") && (model.Name.StartsWith("Start")))
{
eventName = model.Name.Substring("Start".Length);
}
/*
* else if (model.CorrelatesTo?.ReturnType == "System.IDisposable" && (model.CorrelatesTo?.Name.StartsWith("Start") ?? false))
* {
* return "";
* }
*/
var output = LoggerImplementationEventMethodTemplate.Template_LOGGER_METHOD;
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_NAME, eventName);
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_EVENTSOURCE_CLASS_NAME, eventSourceModel.ClassName);
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_RETURNTYPE, model.ReturnType ?? "void");
var methodArguments = new EventArgumentsListBuilder(
RenderMethodArgument, LoggerImplementationEventMethodTemplate.Template_LOGGER_IMPLICIT_ARGUMENTS_METHOD_DECLARATION_DELIMITER);
foreach (var argument in model.GetAllNonImplicitArguments())
{
methodArguments.Append(argument);
}
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_ARGUMENTS, methodArguments.ToString());
var methodImplementation = new StringBuilder();
var renderers = new ILoggerImplementationMethodRenderer[]
{
new LoggerImplementationMethodCallEventSourceEventRenderer(),
}.Union(project.GetExtensions <ILoggerImplementationMethodRenderer>()).ToArray();
foreach (var renderer in renderers)
{
methodImplementation.Append(renderer.Render(project, loggerProjectItem, model));
}
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_IMPLEMENTATION, methodImplementation.ToString());
return(output);
}
