Cacher is the code snippet organizer for pro developers

using System;
using System.Globalization;

namespace Helpers.Datetime
{
    public static class DateTimeExtensions
    {
        public static string AsElasticFormat(this DateTime? self, string formatName)
        {
            /*
            https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html

            epoch_millis                        : ToEpochMiliseconds
            epoch_second                        : ToEpochSeconds
            date_optional_time                  : "yyyy-MM-dd"
            strict_date_optional_time           : "yyyy-MM-dd"
            basic_date                          : "yyyyMMdd"
            basic_date_time                     : "yyyyMMddTHHmmss.SSSZ"
            basic_date_time_no_millis           : "yyyyMMddTHHmmssZ"
            basic_ordinal_date                  : "yyyyDDD"
            basic_ordinal_date_time             : "yyyyDDDTHHmmss.SSSZ"
            basic_ordinal_date_time_no_millis   : "yyyyDDDTHHmmssZ"
            basic_time                          : "HHmmss.SSSZ"
            basic_time_no_millis                : "HHmmssZ"
            basic_t_time                        : ...
            date_hour_minute_second             : "yyyy-MM-ddTHH:mm:ss"
            */
            if (self == null) throw new ArgumentNullException(paramName: nameof(self));
            switch (formatName)
            {
                case null:
                    throw new ArgumentNullException(paramName: nameof(formatName));
                case "date_hour_minute_second":
                    return self.AsString(format: "yyyy-MM-ddTHH:mm:ss");
            }

            throw new NotImplementedException();
        }

        public static double ToEpochMiliseconds(this DateTime? self)
        {
            if (self != null)
                return Normalize(self: self.Value)
                    .Subtract(value: new
                        DateTime(year: 1970, month: 1, day: 1, hour: 0, minute: 0, second: 0, kind: self.Value.Kind))
                    .TotalMilliseconds;

            throw new ArgumentNullException(paramName: nameof(self));
        }


        public static double ToEpochSeconds(this DateTime? self)
        {
            if (self != null)
                return Normalize(self: self.Value)
                    .Subtract(value: new
                        DateTime(year: 1970, month: 1, day: 1, hour: 0, minute: 0, second: 0, kind: self.Value.Kind))
                    .TotalSeconds;

            throw new ArgumentNullException(paramName: nameof(self));
        }

        public static string AsString(this DateTime? self, string format, CultureInfo cultureInfo)
        {
            if (self != null) return Normalize(self: self.Value).ToString(format: format, provider: cultureInfo);
            throw new ArgumentNullException(paramName: nameof(self));
        }

        public static string AsString(this DateTime? self, string format)
        {
            if (self != null) return Normalize(self: self.Value).ToString(format: format);
            throw new ArgumentNullException(paramName: nameof(self));
        }

        private static DateTime Normalize(DateTime self)
        {
            var value = self.Kind == DateTimeKind.Unspecified
                ? DateTime.SpecifyKind(value: self, kind: DateTimeKind.Local)
                : self.Kind == DateTimeKind.Local ? self.ToLocalTime() : self.ToUniversalTime();
            return value;
        }

        public static string AsString(this DateTime? self, IFormatProvider formatProvider)
        {
            if (self == null) throw new ArgumentNullException(paramName: nameof(self));
            var value = self.Value.Kind == DateTimeKind.Utc
                ? self.Value.ToUniversalTime()
                : self.Value.ToLocalTime();

            return value.ToString(provider: formatProvider);
        }

        public static DateTime ToDateTime(this string s,
            string format = "ddMMyyyy", string cultureString = "tr-TR")
        {
            var r = DateTime.ParseExact(
                s: s,
                format: format,
                provider: CultureInfo.GetCultureInfo(name: cultureString));
            return r;
        }

        public static DateTime ToDateTime(this string s,
            string format, CultureInfo culture)
        {
            var r = DateTime.ParseExact(s: s, format: format,
                provider: culture);
            return r;
        }
    }
}

using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace PlateHelpers
{
    public static class PlateValidate
    {
        const string REGEX_4DIGITS = @"(?!0000)[0-9]{4}"; // http://stackoverflow.com/a/9074266/1766716
        const string REGEX_3DIGITS = @"0\.[0-9]{3}"; // http://stackoverflow.com/a/28056964/1766716
        const string REGEX_2DIGITS = @"0?[1-9]|[1-9][0-9]"; // http://stackoverflow.com/a/4013014/1766716
        const string REGEX_DIGITS = @"[1-9]";

        const string REGEX_WORD = @"\w{1,3}";
        const string REGEX_VALID_PLATE = @"^(0?[1-9]|[1-9][0-9])([a-zA-Z]{1,4})((?!0000)[0-9]{4}|((?!000)[0-9]{3})|(?!00)[0-9]{2}|((?!0)[0-9]{1}))$";

        public readonly static string pattern;

        public static bool IsValid (string plate) {
            return Regex.Match(input: plate, pattern: REGEX_VALID_PLATE, options: RegexOptions.IgnoreCase).Success;
        }

        static PlateValidate () {
            // Sıra önemli. Önce 
            // { REGEX_DIGITS}|{ REGEX_3DIGITS}
            // derseniz 9999'u 9 olarak yakalıyor.
            pattern = @"^(\d{2})([a-zA-Z]{1,4})(\d{1,4})$";
        }

        public enum Country {
            TR,
            ADB
        }

        public static IList<Match> Matches(string plateNumber) {
            var matches = new List<Match>();
            foreach ( Match match in Regex.Matches(input: plateNumber, pattern: pattern, options: RegexOptions.None) ) {
                matches.Add(match);
            }
            return matches;
        }

        public static string FormatPlate(string plate, Country country) {
            string formatted = "?";

            GroupCollection groups = null;
            switch ( country ) {
                case Country.TR:
                    var matches = Matches(plate);
                    if (matches.Count > 0){
                        groups = matches [0].Groups;
                        string a = groups [1].Value, b = groups [2].Value, c = groups [3].Value;
                        formatted = $"{a} {b} {c}";
                    }

                    break;
                case Country.ADB:
                    break;
                default:
                    break;
            }

            return formatted;
        }
    }
}