public static void Main(string[] args)
{
LayoutRenderer.Register("user-domain", (logEvent) => Environment.UserDomainName);
LayoutRenderer.Register("user-name", (logEvent) => Environment.UserName);
LayoutRenderer.Register("os-version", (logEvent) => Environment.OSVersion);
LayoutRenderer.Register("current-directory", (logEvent) => Environment.CurrentDirectory);
LayoutRenderer.Register("custom-shortdate", (logEvent) => DateTime.Now.ToString("yyyyMMdd"));
LayoutRenderer.Register("application-name", (logEvent) => Assembly.GetExecutingAssembly().FullName);
var logger = NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger();
try
{
//CreateWebHostBuilder(args).Build().Run();
var host = BuildWebHost(args);
host.Run();
}
catch (Exception ex)
{
logger.Error(ex, "Programa parado por causa de uma exception.");
throw;
}
finally
{
NLog.LogManager.Shutdown();
}
}
/// <summary>
/// Initializes the layout.
/// </summary>
protected override void InitializeLayout()
{
for (int i = 0; i < this.Renderers.Count; i++)
{
LayoutRenderer renderer = this.Renderers[i];
try
{
renderer.Initialize(LoggingConfiguration);
}
catch (Exception exception)
{
//also check IsErrorEnabled, otherwise 'MustBeRethrown' writes it to Error
//check for performance
if (InternalLogger.IsWarnEnabled || InternalLogger.IsErrorEnabled)
{
InternalLogger.Warn(exception, "Exception in '{0}.InitializeLayout()'", renderer.GetType().FullName);
}
if (exception.MustBeRethrown())
{
throw;
}
}
}
base.InitializeLayout();
}
/// <summary>
/// 添加NLog日志
/// </summary>
/// <param name="register"></param>
public static IServiceCollection AddNLog(this IServiceCollection services, NLogAspNetCoreOptions options, bool clearProviders = true)
{
services.AddLogging(builder =>
{
if (clearProviders)
{
builder.ClearProviders();
}
builder.SetMinimumLevel(LogLevel.Trace);
});
options = options ?? NLogAspNetCoreOptions.Default;
services.AddSingleton <ILoggerProvider>(serviceProvider =>
{
serviceProvider.SetupNLogServiceLocator();
if (options.RegisterHttpContextAccessor)
{
LayoutRenderer.Register <WebInfoLayoutRenderer>("webinfo");
WebInfoLayoutRenderer.httpContextAccessor = serviceProvider.GetService <IHttpContextAccessor>();
}
return(new NLogLoggerProvider(options));
});
if (options.RegisterHttpContextAccessor)
{
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
}
return(services);
}
public static void Main(string[] args)
{
LayoutRenderer.Register <ExceptionLayoutRenderer>("appy-exception");
LayoutRenderer.Register <CorrelationIdLayoutRenderer>("correlationid");
var url = ConfigurationManager.AppSettings["server.url"];
var gitRepoPath = ConfigurationManager.AppSettings["git.repository.path"];
var remoteUrl = ConfigurationManager.AppSettings["remote.url"];
var userName = ConfigurationManager.AppSettings["remote.user.name"];
var userEmail = ConfigurationManager.AppSettings["remote.user.email"];
var password = ConfigurationManager.AppSettings["remote.user.password"];
if (!int.TryParse(ConfigurationManager.AppSettings["transactions.timeout"], out int transactionTimeout))
{
transactionTimeout = 10;
}
var app = App.Create(url, new LocalGitDb(gitRepoPath, remoteUrl, userName, userEmail, password, transactionTimeout), new List <User>
{
new User {
UserName = "******", Password = ConfigurationManager.AppSettings["GitAdmin"], Roles = new [] { "admin", "read", "write" }
},
new User {
UserName = "******", Password = ConfigurationManager.AppSettings["GitAdmin"], Roles = new [] { "read" }
},
new User {
UserName = "******", Password = ConfigurationManager.AppSettings["GitWriter"], Roles = new [] { "write" }
}
});
using (app.Start())
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
protected static void TestLogger(Action <ILogger, Func <List <string> > > act)
{
// These layout renderers need to registered statically as ultimately ConfigurationItemFactory.Default is called in the call stack.
LayoutRenderer.Register <ApmTraceIdLayoutRenderer>(ApmTraceIdLayoutRenderer.Name); //generic
LayoutRenderer.Register <ApmTransactionIdLayoutRenderer>(ApmTransactionIdLayoutRenderer.Name); //generic
var logFactory = new LogFactory();
var logConfig = new Config.LoggingConfiguration(logFactory);
var ecsLayout = new EcsLayout();
ecsLayout.ExcludeProperties.Add("NotX");
var memoryTarget = new MemoryTarget {
Layout = ecsLayout, OptimizeBufferReuse = true
};
logConfig.AddRule(LogLevel.Trace, LogLevel.Fatal, memoryTarget);
logConfig.DefaultCultureInfo = System.Globalization.CultureInfo.InvariantCulture;
logFactory.Configuration = logConfig;
List <string> GetLogEvents() => memoryTarget.Logs.ToList();
var logger = logFactory.GetCurrentClassLogger();
act(logger, GetLogEvents);
}
static void Main()
{
LayoutRenderer.Register<ProcessStartTimeLayoutRenderer>("process_start_time");
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ServerForm());
}
private void RenderAllRenderers(LogEventInfo logEvent, StringBuilder target)
{
//Memory profiling pointed out that using a foreach-loop was allocating
//an Enumerator. Switching to a for-loop avoids the memory allocation.
for (int i = 0; i < this.Renderers.Count; i++)
{
LayoutRenderer renderer = this.Renderers[i];
try
{
renderer.RenderAppendBuilder(logEvent, target);
}
catch (Exception exception)
{
//also check IsErrorEnabled, otherwise 'MustBeRethrown' writes it to Error
//check for performance
if (InternalLogger.IsWarnEnabled || InternalLogger.IsErrorEnabled)
{
InternalLogger.Warn(exception, "Exception in '{0}.Append()'", renderer.GetType().FullName);
}
if (exception.MustBeRethrown())
{
throw;
}
}
}
}
private void CheckTitlLoop(LayoutRenderer layout)
{
layout.FrameIndex++;
var currentSequenceGroupIndex = layout.SelectedSequenceGroupIndex;
if (currentSequenceGroupIndex == _titleLayoutDesc.Copyright)
{
if (layout.IsLastFrame)
{
layout.SelectedSequenceGroupIndex = _titleLayoutDesc.Intro;
layout.FrameIndex = 0;
}
}
else if (currentSequenceGroupIndex == _titleLayoutDesc.Intro)
{
if (layout.FrameIndex >= 480)
{
layout.SelectedSequenceGroupIndex = _titleLayoutDesc.IntroSkip;
layout.FrameIndex = 0;
}
}
else if (currentSequenceGroupIndex == _titleLayoutDesc.NewGame)
{
if (layout.IsLastFrame)
{
SetStateToGameplay();
}
}
else
{
layout.FrameIndex++;
}
}
protected override void OnDetached()
{
if (Control != null)
{
Control cntrl = Control as Control;
if (cntrl != null)
{
cntrl.Background = prevBrush;
}
}
else
{
LayoutRenderer renderer = Container as LayoutRenderer;
if (renderer != null)
{
renderer.Background = prevBrush;
}
else
{
PageRenderer prenderer = Container as PageRenderer;
if (prenderer != null)
{
prenderer.Background = prevBrush;
}
}
}
prevBrush = null;
}
public void Dispose()
{
if (_mainCanvas != null)
{
if (_popMenuOverlayRenderer != null)
{
_popMenuOverlayRenderer.PointerPressed -= menuOverlayRenderer_PointerPressed;
_popMenuOverlayRenderer.PointerMoved -= menuOverlayRenderer_PointerMoved;
_popMenuOverlayRenderer.PointerReleased -= menuOverlayRenderer_PointerReleased;
_popMenuOverlayRenderer.PointerExited -= menuOverlayRenderer_PointerReleased;
_mainCanvas.Children.Remove(_popMenuOverlayRenderer);
}
if (_backgroundOverlay != null)
{
_backgroundOverlay.Tapped -= _backgroundOverlay_Tapped;
_mainCanvas.Children.Remove(_backgroundOverlay);
}
if (_popupRenderer != null)
{
_mainCanvas.Children.Remove(_popupRenderer);
}
_mainCanvas.SizeChanged -= mainCanvas_SizeChanged;
}
_mainCanvas = null;
_popMenuOverlayRenderer = null;
_backgroundOverlay = null;
_popupRenderer = null;
}
public static IHost BuildHost(string[] args)
{
return(Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging => logging.ClearProviders())
.ConfigureWebHostDefaults(webBuilder => webBuilder
.UseNLog()
.ConfigureAppConfiguration((context, configuration) =>
{
LayoutRenderer.Register <TenantLayoutRenderer>(TenantLayoutRenderer.LayoutRendererName);
var logConfigPath = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == Environments.Development
? "NLog.dev.config"
: "NLog.config";
var environment = context.HostingEnvironment;
environment.ConfigureNLog(logConfigPath);
LogManager.Configuration.Variables["configDir"] = environment.ContentRootPath;
})
.ConfigureKestrel(options => options.AddServerHeader = false)
//todo: remove theme's we don't need
// .UseSetting(WebHostDefaults.HostingStartupExcludeAssembliesKey,
//"TheComingSoonTheme;TheBlogTheme;TheTheme")
// "{TheComingSoonTheme;TheBlogTheme;TheTheme}")
// "TheComingSoonTheme, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")
.UseStartup <Startup>())
.Build());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
EngineContext.Current.ConfigureRequestPipeline(app);
LayoutRenderer.Register("basedir", (logEvent) => env.ContentRootPath);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
// ConfigureEventBus(app);
}
public static void Initialise()
{
LayoutRenderer.Register <PrettyExceptionLayoutRenderer>("pretty-exception");
LayoutRenderer.Register("linefeed", _ => '\n'); // Workaround for newline using Environment.NewLine.
var config = new LoggingConfiguration();
var fileTarget = new FileTarget
{
Name = "file",
FileName = "${basedir}/WebSiteAdvantage.KeePass.Firefox.log",
LineEnding = LineEndingMode.LF,
Encoding = Encoding.UTF8,
Layout = @"${date:format=yyyy-MM-ddTHH\:mm\:ss,fffK} - [${level:uppercase=true}] ${logger}: ${message}${onexception:${linefeed}${pretty-exception}}",
KeepFileOpen = true,
ConcurrentWrites = false,
OpenFileCacheTimeout = 20
};
var bufferedFileTarget = new BufferingTargetWrapper(fileTarget, 5);
config.AddTarget("buffFile", bufferedFileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, bufferedFileTarget));
LogManager.Configuration = config;
}
/// <summary>
/// Renders the layout for the specified logging event by invoking layout renderers
/// that make up the event.
/// </summary>
/// <param name="logEvent">The logging event.</param>
/// <returns>The rendered layout.</returns>
protected override string GetFormattedMessage(LogEventInfo logEvent)
{
if (IsFixedText)
{
return(this.fixedText);
}
string cachedValue;
if (logEvent.TryGetCachedLayoutValue(this, out cachedValue))
{
return(cachedValue);
}
int initialSize = this.maxRenderedLength;
if (initialSize > MaxInitialRenderBufferLength)
{
initialSize = MaxInitialRenderBufferLength;
}
var builder = new StringBuilder(initialSize);
//Memory profiling pointed out that using a foreach-loop was allocating
//an Enumerator. Switching to a for-loop avoids the memory allocation.
for (int i = 0; i < this.Renderers.Count; i++)
{
LayoutRenderer renderer = this.Renderers[i];
try
{
renderer.Render(builder, logEvent);
}
catch (Exception exception)
{
//also check IsErrorEnabled, otherwise 'MustBeRethrown' writes it to Error
//check for performance
if (InternalLogger.IsWarnEnabled || InternalLogger.IsErrorEnabled)
{
InternalLogger.Warn(exception, "Exception in '{0}.Append()'", renderer.GetType().FullName);
}
if (exception.MustBeRethrown())
{
throw;
}
}
}
if (builder.Length > this.maxRenderedLength)
{
this.maxRenderedLength = builder.Length;
}
string value = builder.ToString();
logEvent.AddCachedLayoutValue(this, value);
return(value);
}
/// <summary>
/// Initializes the log manager.
/// </summary>
public static void Initialize()
{
LayoutRenderer.Register <AudioBandExceptionLayoutRenderer>("audioband-exception");
var configFileFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var config = new XmlLoggingConfiguration(Path.Combine(configFileFolder, "nlog.config"));
LogFactory.Configuration = config;
}
/// <summary>
/// set in Session and test
/// </summary>
/// <param name="key">set with this key</param>
/// <param name="value">set this value</param>
/// <param name="expected">expected</param>
/// <param name="appSettingLayoutRenderer"></param>
/// <remarks>IRenderable is internal</remarks>
private void ExecTest(string key, object value, object expected, LayoutRenderer appSettingLayoutRenderer)
{
Session[key] = value;
var rendered = appSettingLayoutRenderer.Render(LogEventInfo.CreateNullEvent());
Assert.Equal(expected, rendered);
}
public LoggerServiceBase(string name)
{
LayoutRenderer.Register <MethodNameLayout>("method-name");
LayoutRenderer.Register <ClaimLayout>("claim");
LayoutRenderer.Register <ConnectionStringLayout>("nlog-connection-string");
logger = NLogBuilder.ConfigureNLog("nlog.config").GetLogger(name);
}
private static void InitializeNLog()
{
// LogManager.ThrowExceptions = true;
// LogManager.ThrowConfigExceptions = true;
LayoutRenderer.Register("unixtimestamp", (logEvent) => (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalMilliseconds);
LogManager.Configuration = LogManager.Configuration.Reload();
LogManager.ReconfigExistingLoggers();
}
public static IApplicationBuilder UseNLogWeb(this IApplicationBuilder app, ILoggerFactory loggerFactory)
{
LayoutRenderer.Register <TenantLayoutRenderer>(TenantLayoutRenderer.LayoutRendererName);
loggerFactory.AddNLog();
app.AddNLogWeb();
return(app);
}
void FuncLayoutRendererRegisterTest1()
{
LayoutRenderer.Register("the-answer", (info) => "42");
Layout l = "${the-answer}";
var result = l.Render(LogEventInfo.CreateNullEvent());
Assert.Equal("42", result);
}
/// <summary>
/// 注册NLog日志操作
/// </summary>
/// <param name="services">服务集合</param>
public static void AddNLog(this IServiceCollection services)
{
LayoutRenderer.Register <NLogLayoutRenderer>("log");
services.TryAddScoped <ILogProviderFactory, YF.Logs.NLog.LogProviderFactory>();
services.TryAddSingleton <ILogFormat, ContentFormat>();
services.TryAddScoped <ILogContext, LogContext>();
services.TryAddScoped <ILog, Log>();
}
void FuncLayoutRendererRegisterTest2()
{
LayoutRenderer.Register("message-length", (info) => info.Message.Length);
Layout l = "${message-length}";
var result = l.Render(LogEventInfo.Create(LogLevel.Error, "logger-adhoc", "1234567890"));
Assert.Equal("10", result);
}
public static void Main(string[] arguments)
{
LayoutRenderer.Register("appData", _ => AppData.GetFolder());
App app = new App();
app.InitializeComponent();
app.Run();
}
public void CreateController_WithNullContext_ThrowsException()
{
SystemManager.RunWithHttpContext(null, () =>
{
var layoutTemplateBuilder = new LayoutRenderer();
layoutTemplateBuilder.CreateController();
});
}
public static void Main()
{
NLog.Config.ConfigurationItemFactory.Default = new NLog.Config.ConfigurationItemFactory(typeof(NLog.ILogger).GetTypeInfo().Assembly);
LayoutRenderer.Register <Int32HexLayoutRenderer>("int32hex");
Directory.SetCurrentDirectory(Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName));
CreateWebHostBuilder().Build().Run();
NLog.LogManager.Flush();
NLog.LogManager.Shutdown();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider serviceProvider, ILoggerFactory loggerFactory)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
loggerFactory.AddNLog();
app.UseSession();
app.AddNLogWeb();
//注册根目录地址
LayoutRenderer.Register("basedir", (logEvent) => env.ContentRootPath);
HttpContext.Configure(app.ApplicationServices.
GetRequiredService <Microsoft.AspNetCore.Http.IHttpContextAccessor>()
);
app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AuthenticationScheme = "SysManager",
LoginPath = "/SysManager/Account/Login",
LogoutPath = "/SysManager/Account/LoginOut",
AccessDeniedPath = "/SysManager/Account/Login",
AutomaticAuthenticate = true,
AutomaticChallenge = true,
CookieHttpOnly = true,
ExpireTimeSpan = new TimeSpan(0, 0, 30, 0),
CookiePath = "/"
});
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseWebpackDevMiddleware(new WebpackDevMiddlewareOptions
{
HotModuleReplacement = true
});
}
else
{
app.UseExceptionHandler("/Home/Error");
}
//
app.UseMiddleware <CaptchaMiddleware>();
app.UseWebSockets();
app.MapWebSocketManager("/LiveChat", serviceProvider.GetService <ChartHandler>());
app.UseStaticFiles();
//app.UseMiddleware<LoggerMiddleware>();
app.UseMvc(routes =>
{
routes.MapRoute("areaRoute", "{area:exists}/{controller=Home}/{action=Index}/{id?}");
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
routes.MapSpaFallbackRoute("spa-fallback", new { controller = "Home", action = "Index" });
});
}
public void SessionWithCulture()
{
LayoutRenderer.Register <AspNetSessionValueLayoutRenderer>("aspnet-session");
Layout layout = "${aspnet-session:a.b:culture=en-GB:evaluateAsNestedProperties=true}";
var o = new { b = new DateTime(2015, 11, 24, 2, 30, 23) };
//set in "a"
ExecTest("a", o, "24/11/2015 02:30:23", layout);
}
public static IApplicationBuilder UseNLogWeb(this IApplicationBuilder app, ILoggerFactory loggerFactory, IHostingEnvironment env)
{
LayoutRenderer.Register <TenantLayoutRenderer>(TenantLayoutRenderer.LayoutRendererName);
loggerFactory.AddNLog();
app.AddNLogWeb();
env.ConfigureNLog($"{env.ContentRootPath}{Path.DirectorySeparatorChar}NLog.config");
LogManager.Configuration.Variables["configDir"] = env.ContentRootPath;
return(app);
}
private static void ConfigureLogging(string configPath, ConfigurationRoot configurationRoot)
{
var assembly = Assembly.GetExecutingAssembly();
GlobalDiagnosticsContext.Set("Application", assembly.GetName().Name);
GlobalDiagnosticsContext.Set("Version", assembly.GetName().Version);
GlobalDiagnosticsContext.Set("LogPath", configurationRoot.Logging.LogPath);
LayoutRenderer.Register("context", _ => 1);
LogManager.Configuration = new XmlLoggingConfiguration(Path.Combine(configPath, "nlog.config"));
}
internal static LayoutRenderer[] CompileLayout(ConfigurationItemFactory configurationItemFactory, Tokenizer sr, bool isNested, out string text)
{
var result = new List <LayoutRenderer>();
var literalBuf = new StringBuilder();
int ch;
int p0 = sr.Position;
while ((ch = sr.Peek()) != -1)
{
if (isNested && (ch == '}' || ch == ':'))
{
break;
}
sr.Read();
if (ch == '$' && sr.Peek() == '{')
{
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
LayoutRenderer newLayoutRenderer = ParseLayoutRenderer(configurationItemFactory, sr);
if (CanBeConvertedToLiteral(newLayoutRenderer))
{
newLayoutRenderer = ConvertToLiteral(newLayoutRenderer);
}
// layout renderer
result.Add(newLayoutRenderer);
}
else
{
literalBuf.Append((char)ch);
}
}
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
int p1 = sr.Position;
MergeLiterals(result);
text = sr.Substring(p0, p1);
return(result.ToArray());
}
private void UpdateRenderer(LayoutRenderer renderer)
{
LayoutOptions layoutOptions = (LayoutOptions) this.Options;
if (layoutOptions.Renderer == renderer)
return;
layoutOptions.Renderer = renderer;
layoutOptions.Apply();
this.OptionsChanged = true;
}
private static LayoutRenderer ConvertToLiteral(LayoutRenderer renderer)
{
StringBuilder sb = new StringBuilder();
renderer.Append(sb, LogEventInfo.CreateNullEvent());
return new LiteralLayoutRenderer(sb.ToString());
}
/// <summary>
/// Determines whether this LayoutRendererDictionary contains a specific value.
/// </summary>
/// <param name="value">
/// The LayoutRenderer value to locate in this LayoutRendererDictionary.
/// </param>
/// <returns>
/// true if this LayoutRendererDictionary contains an element with the specified value;
/// otherwise, false.
/// </returns>
public virtual bool ContainsValue(LayoutRenderer value)
{
foreach (LayoutRenderer item in this.Dictionary.Values)
{
if (item == value)
return true;
}
return false;
}
/// <summary>
/// Adds an element with the specified key and value to this LayoutRendererDictionary.
/// </summary>
/// <param name="key">
/// The string key of the element to add.
/// </param>
/// <param name="value">
/// The LayoutRenderer value of the element to add.
/// </param>
public virtual void Add(string key, LayoutRenderer value)
{
this.Dictionary.Add(key, value);
}
private static void ApplyLayoutRendererParameters(LayoutRenderer target, string parameterString)
{
int pos = 0;
while (pos < parameterString.Length)
{
int nameStartPos = pos;
while (pos < parameterString.Length && Char.IsWhiteSpace(parameterString[pos]))
{
pos++;
}
while (pos < parameterString.Length && parameterString[pos] != '=')
{
pos++;
}
int nameEndPos = pos;
if (nameStartPos == nameEndPos)
break;
pos++;
// we've got a name - now get a value
//
StringBuilder valueBuf = new StringBuilder();
while (pos < parameterString.Length)
{
if (parameterString[pos] == '\\')
{
valueBuf.Append(parameterString[pos + 1]);
pos += 2;
}
else if (parameterString[pos] == ':')
{
pos++;
break;
}
else
{
valueBuf.Append(parameterString[pos]);
pos++;
}
}
string name = parameterString.Substring(nameStartPos, nameEndPos - nameStartPos);
string value = valueBuf.ToString();
PropertyHelper.SetPropertyFromString(target, name, value, null);
}
}
internal Layout(LayoutRenderer[] renderers, string text)
{
SetRenderers(renderers, text);
}
internal void SetRenderers(LayoutRenderer[] renderers, string text)
{
_renderers = renderers;
if (_renderers.Length == 1 && _renderers[0] is LiteralLayoutRenderer)
_fixedText = ((LiteralLayoutRenderer)(_renderers[0])).Text;
else
_fixedText = null;
_layoutText = text;
_isVolatile = false;
_needsStackTrace = 0;
foreach (LayoutRenderer lr in renderers)
{
int nst = lr.NeedsStackTrace();
if (nst > _needsStackTrace)
_needsStackTrace = nst;
if (lr.IsVolatile())
_isVolatile = true;
}
}
