Пример #1
0
    /// <summary>
    /// Intercepts logs from the console and provides the ability to flush them to a file in the event of a crash.
    /// </summary>
    /// <param name="logger">The logger to intercept logs from.</param>
    /// <param name="outputDir">The directory to which the log is output to.</param>
    public LogWriter(Logger logger, string outputDir)
    {
        var executableName    = Path.GetFileNameWithoutExtension(Environment.GetCommandLineArgs()[0]);
        var universalDateTime = DateTime.UtcNow.ToString("yyyy-MM-dd HH.mm.ss");

        Directory.CreateDirectory(outputDir);

        _logItems = new List <string>(MaxBufferLength + 1);
        _logger   = logger;
        _logger.OnPrintMessage += OnPrintMessage;

        // Add integer to file path in case there is another instance of same process launched at the same time.
        string GetLogFilePath()
        {
            for (int x = 0; x < short.MaxValue; x++)
            {
                var filePath = x == 0 ?
                               Path.Combine(outputDir, $"{universalDateTime} ~ {executableName}.txt") :
                               Path.Combine(outputDir, $"{universalDateTime} ~ {executableName} [{x}].txt");

                if (!File.Exists(filePath))
                {
                    return(filePath);
                }
            }

            return(default);
Пример #2
0
 private static void PopulateCommandLineArgs()
 {
     string[] args = Environment.GetCommandLineArgs();
     for (int index = 1; index < args.Length; index += 2)
     {
         _commandLineArguments.Add(args[index], args[index + 1]);
     }
 }
Пример #3
0
 public static string GetCommandLineArg(string name)
 {
     foreach (var argument in Environment.GetCommandLineArgs())
     {
         var parts = argument.Split(CmdArgumentDelimiters, 2);
         if (parts.Length == 2 && parts[0].Equals(name))
         {
             return(parts[1]);
         }
     }
     return(null);
 }
Пример #4
0
    static void Main()
    {
        string s = "";

        s += "\n当前程序名:\t"
             + Env.GetCommandLineArgs()[0];
        s += "\n当前目录:\t"
             + Env.CurrentDirectory;
        s += "\nWin操作系统:\t"
             + (Env.OSVersion.Platform == PlatformID.Win32NT);
        s += "\n环境变量Temp:\t"
             + Env.GetEnvironmentVariable("temp");

        Console.WriteLine(s);
    }
Пример #5
0
            /// <summary>
            /// Adds the command line arguments starting with <paramref name="prefixes"/> into the <see cref="Configuration"/>.
            /// When a configuration item exists, the value is updated.
            /// </summary>
            /// <remarks>
            ///The command line arguments have the syntax <c>key=value</c> (for example <c>Key1=Option1</c>or
            /// <c>prefixkey=value</c> (for example <c>-p:Key1=Option1</c> where <c>-p:</c> is the prefix).
            /// When the prefixes are not provided, all command line arguments are added to the configuration.
            /// When the prefixes are provided,the prefix is not a part of the key.
            /// <para>
            /// The implementation  of binding treats the <see cref="bool"/> values the special way - if there is no value, but existing key,
            /// the value is converted to true, allowing to use the parameters like flags. For example having the argument <c>-p:SkipStep1</c>
            /// and prefix <c>-p:</c>, the binding a bool property <c>SkipStep1</c> will set the value of the property to <c>true</c>
            /// (doesn't change the configuration item itself). Of course, it's still possible to use the syntax <c>-p:SkipStep1=true</c> or
            /// <c>-p:SkipStep1=false</c> even in this case.
            /// </para>
            /// </remarks>
            /// <param name="prefixes">Optional list of prefixes marking the command line arguments to be the configuration items</param>
            /// <returns>The current <see cref="ConfigurationBuilder"/></returns>
            public ConfigurationBuilder AddCommandLineArguments(params string[] prefixes)
            {
                foreach (var argRaw in Environment.GetCommandLineArgs())
                {
                    if (prefixes != null && !prefixes.Any(p => argRaw.StartsWith(p)))
                    {
                        continue;
                    }

                    var arg = argRaw;
                    if (prefixes != null)
                    {
                        arg = argRaw.Substring(prefixes.First(p => arg.StartsWith(p)).Length);
                    }

                    var argSplit = arg.Split(new[] { '=' }, 2);
                    var argKey   = argSplit[0];
                    var argValue = argSplit.Length > 1 ? argSplit[1] : null;
                    Instance.AddOrUpdateItem(argKey, argValue);
                }
                return(this);
            }
Пример #6
0
 public IReadOnlyList <string> GetCommandLineArgs()
 {
     return(Env.GetCommandLineArgs());
 }
Пример #7
0
 public static bool GetCommandLineFlag(string name)
 {
     return(Array.IndexOf(Environment.GetCommandLineArgs(), name) >= 0);
 }
Пример #8
0
        static CommandLine()
        {
            var args = Environment.GetCommandLineArgs();

            Arguments = new CommandLineArguments(args.Skip(1));
        }
Пример #9
0
 static bool HasOption(string option)
 {
     return(Env.GetCommandLineArgs().Contains(option));
 }
 public static string[] GetCommandLineArgs()
 {
     return(Env.GetCommandLineArgs());
 }