C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using Towel;
using static Towel.Syntax;

namespace ConsoleCoreSandbox
{
	class Program
	{
		// This code is a snippet from the https://github.com/ZacharyPatten/Towel project.
		// Please check out the project if you want to see more code like it. :)

		// This is some code that aims to help you handle command line arguments to Console
		// applications. Just add "CommandLine.Argument" fields to the class of your entry
		// point and they will be automatically resolved.
		//
		// The "HasValue" property returns true if the argument was
		// provided or a default value exists.
		//
		// The "Status" property gives you information about the argument.
		// - Default: The arguemnt was not provided but a default value exists.
		// - SyntaxError: The definition of the CommandLineArgument is invalid (not supported). The code needs to be updated.
		// - NotProvided: The argument was not provided by the command line arguments and no default exists.
		// - DuplicateProvided: The argument was provided multiple times. The command line arguments are invalid.
		// - ParseFailed: The argument was provided, but the relative value was not valid.
		// - ValueProvided: The argument was provided and successfully parsed.
		//
		// Examples Of Command Lines:
		// dotnet THISAPP A: helloworld
		// dotnet THISAPP B: 7
		// dotnet THISAPP A: hello B: 7 C: 8.8 D: world
		// dotnet THISAPP Help
		// dotnet THISAPP Version

		static CommandLine.Argument Version;
		static CommandLine.Argument Help;
		static CommandLine.Argument<string> A = "default";
		static CommandLine.Argument<int> B = 7;
		static CommandLine.Argument<float> C = 8.5f;
		static CommandLine.Argument<string> D;

		static void Main()
		{
			if (Version.Exists || Help.Exists)
			{
				Console.WriteLine(CommandLine.GetDefaultInfoString);
				Console.WriteLine("  Summary: TODO");
				Console.WriteLine("  Documentation: TODO");
				Console.WriteLine("  Contact(s): TODO");
				return;
			}

			Console.WriteLine(A);
			Console.WriteLine(B + 1);
			Console.WriteLine(C + 1.5);
			Console.WriteLine(D.HasValue ? D.Value : nameof(D) + ": " + D.Status);
		}
	}
}

#region Towel Definitions

namespace Towel
{
	public static class CommandLine
	{
		internal static string[] Args = Environment.GetCommandLineArgs();

		public static string GetDefaultInfoString
		{
			get
			{
				StringBuilder stringBuilder = new StringBuilder();
				Assembly entryAssembly = Assembly.GetEntryAssembly();
				AssemblyName assemblyName = entryAssembly.GetName();
				stringBuilder.Append("  Name: ");
				stringBuilder.AppendLine(assemblyName.Name);
				stringBuilder.Append("  Version: ");
				stringBuilder.AppendLine(assemblyName.Version.ToString());
				stringBuilder.Append("  Command Line Arguments:");
				MethodInfo entryMethod = entryAssembly.EntryPoint;
				Type entryType = entryMethod.DeclaringType;
				FieldInfo[] fieldInfos = entryType.GetFields(
					BindingFlags.Static |
					BindingFlags.Public |
					BindingFlags.NonPublic);
				bool hasCommandLineArguments = false;
				for (int i = 0; i < fieldInfos.Length; i++)
				{
					FieldInfo field = fieldInfos[i];
					object fieldValue = field.GetValue(null);
					if (fieldValue is IGenericArgument genericArgument)
					{
						hasCommandLineArguments = true;
						stringBuilder.AppendLine();
						stringBuilder.Append("    ");
						stringBuilder.Append(field.Name);
						stringBuilder.AppendLine(":");
						stringBuilder.Append("      Type: ");
						stringBuilder.Append(genericArgument.Type.Name);
						if (genericArgument.HasDefaultValue)
						{
							stringBuilder.AppendLine();
							stringBuilder.Append("      Default: ");
							stringBuilder.Append(genericArgument.DefaultValueString);
						}
					}
					else if (fieldValue is Argument)
					{
						hasCommandLineArguments = true;
						stringBuilder.AppendLine();
						stringBuilder.Append("    ");
						stringBuilder.Append(field.Name);
					}
				}
				if (!hasCommandLineArguments)
				{
					stringBuilder.Append("      None");
				}
				string result = stringBuilder.ToString();
				return result;
			}
		}

		public enum ArgumentStatus
		{
			Null = 0,
			Default,
			SyntaxError,
			NotProvided,
			DuplicateProvided,
			ParseFailed,
			ValueProvided,
		}

		public struct Argument
		{
			internal class Data
			{
				internal ArgumentStatus _status;
			}

			internal Data _data;

			public bool Exists
			{
				get
				{
					Process();
					return _data._status is ArgumentStatus.ValueProvided;
				}
			}

			public ArgumentStatus Status
			{
				get
				{
					Process();
					return _data._status;
				}
			}

			internal void Process()
			{
				_data ??= new Data();
				if (!(_data._status is ArgumentStatus.Null))
				{
					return;
				}
				Assembly entryAssembly = Assembly.GetEntryAssembly();
				MethodInfo entryMethod = entryAssembly.EntryPoint;
				Type entryType = entryMethod.DeclaringType;
				FieldInfo[] fieldInfos = entryType.GetFields(
					BindingFlags.Static |
					BindingFlags.Public |
					BindingFlags.NonPublic);
				foreach (FieldInfo field in fieldInfos)
				{
					if (field.GetValue(null) is Argument argumentT)
					{
						if (argumentT._data is null || !(argumentT._data._status is ArgumentStatus.Null))
						{
							continue;
						}
						if (argumentT._data == _data)
						{
							string name = field.Name;
							int index = -1;
							for (int i = 0; i < Args.Length; i++)
							{
								if (Args[i] == name)
								{
									if (index > -1)
									{
										_data._status = ArgumentStatus.DuplicateProvided;
										return;
									}
									else
									{
										index = i;
									}
								}
							}
							if (index == -1)
							{
								_data._status = ArgumentStatus.NotProvided;
								return;
							}
							else
							{
								_data._status = ArgumentStatus.ValueProvided;
								return;
							}
						}
					}
				}
				_data._status = ArgumentStatus.SyntaxError;
				return;
			}
		}

		internal interface IGenericArgument
		{
			bool HasDefaultValue { get; }
			string DefaultValueString { get; }
			Type Type { get; }
		}

		public struct Argument<T> : IGenericArgument
		{
			internal class Data
			{
				internal ArgumentStatus _status;
				internal T _value;
				internal T _defaultValue;
				internal bool _hasDefault;
			}

			internal Data _data;

			public T Value
			{
				get
				{
					Process();
					return _data._status is ArgumentStatus.ValueProvided || _data._status is ArgumentStatus.Default
						? _data._value
						: throw new InvalidOperationException("Attempted to get a command line argument with a status of " + _data._status + ".");
				}
			}

			public bool HasDefaultValue
			{
				get
				{
					Process();
					return _data._hasDefault;
				}
			}

			public T DefaultValue
			{
				get
				{
					Process();
					return _data._hasDefault
						? _data._defaultValue
						: throw new InvalidOperationException("Attempted to get the default value of a command line argument with no default value.");
				}
			}

			public string DefaultValueString
			{
				get
				{
					Process();
					return _data._hasDefault
						? _data._defaultValue.ToString()
						: throw new InvalidOperationException("Attempted to get the default value string of a command line argument with no default value.");
				}
			}

			public bool HasValue
			{
				get
				{
					Process();
					return _data._status is ArgumentStatus.ValueProvided || _data._status is ArgumentStatus.Default;
				}
			}

			public ArgumentStatus Status
			{
				get
				{
					Process();
					return _data._status;
				}
			}

			public Type Type => typeof(T);

			internal void Process()
			{
				_data ??= new Data();
				if (!(_data._status is ArgumentStatus.Null))
				{
					return;
				}
				Assembly entryAssembly = Assembly.GetEntryAssembly();
				MethodInfo entryMethod = entryAssembly.EntryPoint;
				Type entryType = entryMethod.DeclaringType;
				FieldInfo[] fieldInfos = entryType.GetFields(
					BindingFlags.Static |
					BindingFlags.Public |
					BindingFlags.NonPublic);
				foreach (FieldInfo field in fieldInfos)
				{
					if (field.GetValue(null) is Argument<T> argumentT)
					{
						if (argumentT._data is null || !(argumentT._data._status is ArgumentStatus.Null))
						{
							continue;
						}
						if (argumentT._data == _data)
						{
							string name = field.Name + ":";
							int index = -1;
							for (int i = 0; i < Args.Length; i++)
							{
								if (Args[i] == name)
								{
									if (index > -1)
									{
										_data._status = ArgumentStatus.DuplicateProvided;
										return;
									}
									else
									{
										index = i;
									}
								}
							}
							if (index == -1)
							{
								if (_data._hasDefault)
								{
									_data._status = ArgumentStatus.Default;
									return;
								}
								else
								{
									_data._status = ArgumentStatus.NotProvided;
									return;
								}
							}
							else if (index == Args.Length - 1)
							{
								_data._status = ArgumentStatus.NotProvided;
								return;
							}
							else if (typeof(T) == typeof(string))
							{
								Argument<string>.Data data_string = _data as Argument<string>.Data;
								data_string._value = Args[index + 1];
								_data._status = ArgumentStatus.ValueProvided;
								return;
							}
							else if (TryParse(Args[index + 1], out _data._value))
							{
								_data._status = ArgumentStatus.ValueProvided;
								return;
							}
							else
							{
								_data._status = ArgumentStatus.ParseFailed;
								return;
							}
						}
					}
				}
				_data._status = ArgumentStatus.SyntaxError;
				return;
			}

			public static implicit operator T(Argument<T> argument) => argument.Value;

			public static implicit operator Argument<T>(T value) =>
				new Argument<T>()
				{
					_data = new Data()
					{
						_defaultValue = value,
						_hasDefault = true,
						_value = value,
					}
				};
		}
	}

	public static class Meta
	{
		public static MethodInfo GetTryParseMethod<A>() => GetTryParseMethodCache<A>.Value;

		public static MethodInfo GetTryParseMethod(Type a)
		{
			_ = a ?? throw new ArgumentNullException(nameof(a));
			MethodInfo methodInfo = a.GetMethod("TryParse",
				BindingFlags.Static |
				BindingFlags.Public |
				BindingFlags.NonPublic,
				null,
				new Type[] { typeof(string), a.MakeByRefType() },
				null);
			return !(methodInfo is null)
				&& methodInfo.ReturnType == typeof(bool)
					? methodInfo
					: null;
		}

		internal static class GetTryParseMethodCache<A>
		{
			internal static readonly MethodInfo Value = GetTryParseMethod(typeof(A));
		}
	}

	public static class Syntax
	{
		public static A TryParse<A>(string @string, A Default = default) =>
			TryParse(@string, out A value)
			? value
			: Default;

		public static bool TryParse<A>(string @string, out A value) =>
			TryParseImplementation<A>.Function(@string, out value);

		internal static class TryParseImplementation<A>
		{
			internal static TryParse<A> Function = (string @string, out A value) =>
			{
				static bool Default(string @string, out A value)
				{
					value = default;
					return false;
				}

				MethodInfo methodInfo = Meta.GetTryParseMethod<A>();
				Function = methodInfo is null
					? Default
					: (TryParse<A>)methodInfo.CreateDelegate(typeof(TryParse<A>));
				return Function(@string, out value);
			};
		}
	}

	public delegate bool TryParse<T>(string @string, out T value);
}

#endregion

​x
 
using System;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using Towel;
using static Towel.Syntax;
​
namespace ConsoleCoreSandbox
{
    class Program
    {
        // This code is a snippet from the https://github.com/ZacharyPatten/Towel project.
        // Please check out the project if you want to see more code like it. :)
​
        // This is some code that aims to help you handle command line arguments to Console
        // applications. Just add "CommandLine.Argument" fields to the class of your entry
        // point and they will be automatically resolved.
        //
        // The "HasValue" property returns true if the argument was
        // provided or a default value exists.
        //
        // The "Status" property gives you information about the argument.
        // - Default: The arguemnt was not provided but a default value exists.
        // - SyntaxError: The definition of the CommandLineArgument is invalid (not supported). The code needs to be updated.
        // - NotProvided: The argument was not provided by the command line arguments and no default exists.
        // - DuplicateProvided: The argument was provided multiple times. The command line arguments are invalid.
        // - ParseFailed: The argument was provided, but the relative value was not valid.
        // - ValueProvided: The argument was provided and successfully parsed.
        //
        // Examples Of Command Lines:
        // dotnet THISAPP A: helloworld
        // dotnet THISAPP B: 7
        // dotnet THISAPP A: hello B: 7 C: 8.8 D: world
        // dotnet THISAPP Help
        // dotnet THISAPP Version
​
        static CommandLine.Argument Version;
        static CommandLine.Argument Help;
        static CommandLine.Argument<string> A = "default";
        static CommandLine.Argument<int> B = 7;
        static CommandLine.Argument<float> C = 8.5f;
        static CommandLine.Argument<string> D;
​
        static void Main()
        {
            if (Version.Exists || Help.Exists)
            {
                Console.WriteLine(CommandLine.GetDefaultInfoString);
                Console.WriteLine("  Summary: TODO");
                Console.WriteLine("  Documentation: TODO");
                Console.WriteLine("  Contact(s): TODO");
                return;
            }
​
            Console.WriteLine(A);
            Console.WriteLine(B + 1);
            Console.WriteLine(C + 1.5);
            Console.WriteLine(D.HasValue ? D.Value : nameof(D) + ": " + D.Status);
        }
    }
}
​
#region Towel Definitions
​
namespace Towel
{
    public static class CommandLine
    {
        internal static string[] Args = Environment.GetCommandLineArgs();
​
        public static string GetDefaultInfoString
        {
            get
            {
                StringBuilder stringBuilder = new StringBuilder();
                Assembly entryAssembly = Assembly.GetEntryAssembly();
                AssemblyName assemblyName = entryAssembly.GetName();
                stringBuilder.Append("  Name: ");
                stringBuilder.AppendLine(assemblyName.Name);
                stringBuilder.Append("  Version: ");
                stringBuilder.AppendLine(assemblyName.Version.ToString());
                stringBuilder.Append("  Command Line Arguments:");
                MethodInfo entryMethod = entryAssembly.EntryPoint;
                Type entryType = entryMethod.DeclaringType;
                FieldInfo[] fieldInfos = entryType.GetFields(
                    BindingFlags.Static |
                    BindingFlags.Public |
                    BindingFlags.NonPublic);
                bool hasCommandLineArguments = false;
                for (int i = 0; i < fieldInfos.Length; i++)
                {
                    FieldInfo field = fieldInfos[i];
                    object fieldValue = field.GetValue(null);
                    if (fieldValue is IGenericArgument genericArgument)
                    {
                        hasCommandLineArguments = true;
                        stringBuilder.AppendLine();
                        stringBuilder.Append("    ");
                        stringBuilder.Append(field.Name);
                        stringBuilder.AppendLine(":");
                        stringBuilder.Append("      Type: ");
                        stringBuilder.Append(genericArgument.Type.Name);
                        if (genericArgument.HasDefaultValue)
                        {
                            stringBuilder.AppendLine();
                            stringBuilder.Append("      Default: ");
                            stringBuilder.Append(genericArgument.DefaultValueString);
                        }
                    }
                    else if (fieldValue is Argument)
                    {
                        hasCommandLineArguments = true;
                        stringBuilder.AppendLine();
                        stringBuilder.Append("    ");
                        stringBuilder.Append(field.Name);
                    }
                }
                if (!hasCommandLineArguments)
                {
                    stringBuilder.Append("      None");
                }
                string result = stringBuilder.ToString();
                return result;
            }
        }
​
        public enum ArgumentStatus
        {
            Null = 0,
            Default,
            SyntaxError,
            NotProvided,
            DuplicateProvided,
            ParseFailed,
            ValueProvided,
        }
​
        public struct Argument
        {
            internal class Data
            {
                internal ArgumentStatus _status;
            }
​
            internal Data _data;
​
            public bool Exists
            {
                get
                {
                    Process();
                    return _data._status is ArgumentStatus.ValueProvided;
                }
            }
​
            public ArgumentStatus Status
            {
                get
                {
                    Process();
                    return _data._status;
                }
            }
​
            internal void Process()
            {
                _data ??= new Data();
                if (!(_data._status is ArgumentStatus.Null))
                {
                    return;
                }
                Assembly entryAssembly = Assembly.GetEntryAssembly();
                MethodInfo entryMethod = entryAssembly.EntryPoint;
                Type entryType = entryMethod.DeclaringType;
                FieldInfo[] fieldInfos = entryType.GetFields(
                    BindingFlags.Static |
                    BindingFlags.Public |
                    BindingFlags.NonPublic);
                foreach (FieldInfo field in fieldInfos)
                {
                    if (field.GetValue(null) is Argument argumentT)
                    {
                        if (argumentT._data is null || !(argumentT._data._status is ArgumentStatus.Null))
                        {
                            continue;
                        }
                        if (argumentT._data == _data)
                        {
                            string name = field.Name;
                            int index = -1;
                            for (int i = 0; i < Args.Length; i++)
                            {
                                if (Args[i] == name)
                                {
                                    if (index > -1)
                                    {
                                        _data._status = ArgumentStatus.DuplicateProvided;
                                        return;
                                    }
                                    else
                                    {
                                        index = i;
                                    }
                                }
                            }
                            if (index == -1)
                            {
                                _data._status = ArgumentStatus.NotProvided;
                                return;
                            }
                            else
                            {
                                _data._status = ArgumentStatus.ValueProvided;
                                return;
                            }
                        }
                    }
                }
                _data._status = ArgumentStatus.SyntaxError;
                return;
            }
        }
​
        internal interface IGenericArgument
        {
            bool HasDefaultValue { get; }
            string DefaultValueString { get; }
            Type Type { get; }
        }
​
        public struct Argument<T> : IGenericArgument
        {
            internal class Data
            {
                internal ArgumentStatus _status;
                internal T _value;
                internal T _defaultValue;
                internal bool _hasDefault;
            }
​
            internal Data _data;
​
            public T Value
            {
                get
                {
                    Process();
                    return _data._status is ArgumentStatus.ValueProvided || _data._status is ArgumentStatus.Default
                        ? _data._value
                        : throw new InvalidOperationException("Attempted to get a command line argument with a status of " + _data._status + ".");
                }
            }
​
            public bool HasDefaultValue
            {
                get
                {
                    Process();
                    return _data._hasDefault;
                }
            }
​
            public T DefaultValue
            {
                get
                {
                    Process();
                    return _data._hasDefault
                        ? _data._defaultValue
                        : throw new InvalidOperationException("Attempted to get the default value of a command line argument with no default value.");
                }
            }
​
            public string DefaultValueString
            {
                get
                {
                    Process();
                    return _data._hasDefault
                        ? _data._defaultValue.ToString()
                        : throw new InvalidOperationException("Attempted to get the default value string of a command line argument with no default value.");
                }
            }
​
            public bool HasValue
            {
                get
                {
                    Process();
                    return _data._status is ArgumentStatus.ValueProvided || _data._status is ArgumentStatus.Default;
                }
            }
​
            public ArgumentStatus Status
            {
                get
                {
                    Process();
                    return _data._status;
                }
            }
​
            public Type Type => typeof(T);
​
            internal void Process()
            {
                _data ??= new Data();
                if (!(_data._status is ArgumentStatus.Null))
                {
                    return;
                }
                Assembly entryAssembly = Assembly.GetEntryAssembly();
                MethodInfo entryMethod = entryAssembly.EntryPoint;
                Type entryType = entryMethod.DeclaringType;
                FieldInfo[] fieldInfos = entryType.GetFields(
                    BindingFlags.Static |
                    BindingFlags.Public |
                    BindingFlags.NonPublic);
                foreach (FieldInfo field in fieldInfos)
                {
                    if (field.GetValue(null) is Argument<T> argumentT)
                    {
                        if (argumentT._data is null || !(argumentT._data._status is ArgumentStatus.Null))
                        {
                            continue;
                        }
                        if (argumentT._data == _data)
                        {
                            string name = field.Name + ":";
                            int index = -1;
                            for (int i = 0; i < Args.Length; i++)
                            {
                                if (Args[i] == name)
                                {
                                    if (index > -1)
                                    {
                                        _data._status = ArgumentStatus.DuplicateProvided;
                                        return;
                                    }
                                    else
                                    {
                                        index = i;
                                    }
                                }
                            }
                            if (index == -1)
                            {
                                if (_data._hasDefault)
                                {
                                    _data._status = ArgumentStatus.Default;
                                    return;
                                }
                                else
                                {
                                    _data._status = ArgumentStatus.NotProvided;
                                    return;
                                }
                            }
                            else if (index == Args.Length - 1)
                            {
                                _data._status = ArgumentStatus.NotProvided;
                                return;
                            }
                            else if (typeof(T) == typeof(string))
                            {
                                Argument<string>.Data data_string = _data as Argument<string>.Data;
                                data_string._value = Args[index + 1];
                                _data._status = ArgumentStatus.ValueProvided;
                                return;
                            }
                            else if (TryParse(Args[index + 1], out _data._value))
                            {
                                _data._status = ArgumentStatus.ValueProvided;
                                return;
                            }
                            else
                            {
                                _data._status = ArgumentStatus.ParseFailed;
                                return;
                            }
                        }
                    }
                }
                _data._status = ArgumentStatus.SyntaxError;
                return;
            }
​
            public static implicit operator T(Argument<T> argument) => argument.Value;
​
            public static implicit operator Argument<T>(T value) =>
                new Argument<T>()
                {
                    _data = new Data()
                    {
                        _defaultValue = value,
                        _hasDefault = true,
                        _value = value,
                    }
                };
        }
    }
​
    public static class Meta
    {
        public static MethodInfo GetTryParseMethod<A>() => GetTryParseMethodCache<A>.Value;
​
        public static MethodInfo GetTryParseMethod(Type a)
        {
            _ = a ?? throw new ArgumentNullException(nameof(a));
            MethodInfo methodInfo = a.GetMethod("TryParse",
                BindingFlags.Static |
                BindingFlags.Public |
                BindingFlags.NonPublic,
                null,
                new Type[] { typeof(string), a.MakeByRefType() },
                null);
            return !(methodInfo is null)
                && methodInfo.ReturnType == typeof(bool)
                    ? methodInfo
                    : null;
        }
​
        internal static class GetTryParseMethodCache<A>
        {
            internal static readonly MethodInfo Value = GetTryParseMethod(typeof(A));
        }
    }
​
    public static class Syntax
    {
        public static A TryParse<A>(string @string, A Default = default) =>
            TryParse(@string, out A value)
            ? value
            : Default;
​
        public static bool TryParse<A>(string @string, out A value) =>
            TryParseImplementation<A>.Function(@string, out value);
​
        internal static class TryParseImplementation<A>
        {
            internal static TryParse<A> Function = (string @string, out A value) =>
            {
                static bool Default(string @string, out A value)
                {
                    value = default;
                    return false;
                }
​
                MethodInfo methodInfo = Meta.GetTryParseMethod<A>();
                Function = methodInfo is null
                    ? Default
                    : (TryParse<A>)methodInfo.CreateDelegate(typeof(TryParse<A>));
                return Function(@string, out value);
            };
        }
    }
​
    public delegate bool TryParse<T>(string @string, out T value);
}
​
#endregion
​

Bod má souřadnice X:1 a Y:2
{X:1 Y:2}
{A:{X:10 Y:20} B:{X:40 Y:50}}
Delka cary je: 42.43

Last Run:	8:05:39 am
Compile:	0.11s
Execute:	0.016s
Memory:	40kb
CPU:	0.016s

View IL Code