public static void ConfigureLogger()
        {
            var config = new LoggingConfiguration();

#if DEBUG
            var consoleTarget = new ColoredConsoleTarget()
            {
                Layout = @"${level:uppercase=true}|${logger}:${message}${exception}"
            };

            config.AddTarget("console", consoleTarget);

            var rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget);
            config.LoggingRules.Add(rule1);
#endif
            var fileTarget = new FileTarget()
            {
                FileName         = Path.Combine(PlaynitePaths.ConfigRootPath, "playnite.log"),
                Layout           = "${longdate}|${level:uppercase=true}:${message}${exception:format=toString}",
                KeepFileOpen     = false,
                ArchiveFileName  = Path.Combine(PlaynitePaths.ConfigRootPath, "playnite.{#####}.log"),
                ArchiveAboveSize = 4096000,
                ArchiveNumbering = ArchiveNumberingMode.Sequence,
                MaxArchiveFiles  = 2
            };

            config.AddTarget("file", fileTarget);

            var rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget);
            config.LoggingRules.Add(rule2);

            NLog.LogManager.Configuration = config;
            SDK.LogManager.Init(new NLogLogProvider());
            logger = SDK.LogManager.GetLogger();
        }
示例#2
0
        private Object _EvaluateNode(SDK.ILogger logger, Guid nodeId, bool previewMode)
        {
            _ThreadAffinity.Check();

            CheckCancellation();

            logger?.LogInfo(nodeId.ToString(), "Begin Evaluation...");

            // Get the current node being evaluated
            var nodeInst = _InstanceFunc(nodeId);

            if (nodeInst == null)
            {
                return(null);
            }
            if (nodeInst is _UnknownNode)
            {
                return(null);
            }

            // Next, we retrieve the property values for this node from the DOM
            var nodeProps = _PropertiesFunc(nodeId).AsReadOnly();

            if (nodeProps == null)
            {
                return(null);
            }

            // Assign values and node dependencies. Dependecies are evaluated to its values.
            // NOTE: even in preview mode, dependent nodes are evaluated normally
            nodeInst.EvaluateBindings(nodeProps, xid => _EvaluateNode(logger, xid, false));

            CheckCancellation();

            // evaluate the current node

            try
            {
                var localMonitor = GetLocalProgressMonitor(nodeId);

                if (nodeInst is SDK.ContentFilter filterInst)
                {
                    if (previewMode)
                    {
                        return(SDK.PreviewNode(filterInst, localMonitor, logger));
                    }
                    else
                    {
                        if (System.Diagnostics.Debugger.IsAttached)
                        {
                            return(SDK.DebugNode(filterInst, localMonitor, logger));
                        }
                        else
                        {
                            return(SDK.EvaluateNode(filterInst, localMonitor, logger));
                        }
                    }
                }
                else if (nodeInst is SDK.ContentObject)
                {
                    return(nodeInst);
                }
            }
            catch (Exception ex)
            {
                throw new PluginException(ex);
            }

            throw new NotImplementedException();
        }