C# Char.IsNullOrEmpty方法代码示例

        /// <summary>
        /// Определяет, содержатся ли в искомой строке все до одного из указаных обязательных символов и принадлежат ли все остальные символы к указанным разрешенным. 
        /// Если в искомой строке нет хотя бы одного обязательного символа, возвращается 'false'. 
        /// Если хотя бы один символ искомой строки, не являющийся обязательным, отсутствует при этом в массиве разрешенных, возвращается "false". 
        /// При этом обязательное наличие в искомой строке всех или даже одного символа из разрешенного массива не требуется.  
        /// </summary>
        /// <param name="Input">Входная искомая строка, в которой проходит поиск</param>
        /// <param name="RequiredSymbols">Массив обязательных символов, все из которых должны присутствовать в искомой строке</param>
        /// <param name="AcceptedSymbols">Массив допустимых символов, которые не являются обязательными для присутствия, наличие которых допустимо в искомой строке.</param>
        /// <returns></returns>
        public static Boolean ContainsAllRequiredAndOnlyAccepted(String Input, Char[] RequiredSymbols, Char[] AcceptedSymbols)
        {
            if (Input.IsStringNullOrEmpty() == true) { throw new ArgumentException(ContainsHelpers._ExceptionString_NullOrEmptyString, "Input"); }
            if (RequiredSymbols.IsNullOrEmpty() == true) { throw new ArgumentException("Массив обязательных символов не может быть NULL или пустым", "RequiredSymbols"); }

            if (ContainsHelpers.ContainsAllOf(Input, RequiredSymbols) == false) { return false; }

            Char[] input_array = Input.ToCharArray();
            foreach (char c in input_array)
            {
                if (c.IsIn(RequiredSymbols) == false && c.IsIn(AcceptedSymbols) == false)
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// Определяет, содержатся ли в строке только разрешенные символы, указанные в параметре. Если хотя бы один символ не является разрешенным, возвращается 'false'. 
        /// При этом наличие во входной строке всех разрешенных символов не обязательно.
        /// </summary>
        /// <param name="Input">Входная строка. Если NULL или пустая - генерируется исключение.</param>
        /// <param name="AllowedSymbols">Массив разрешенных символов. Если NULL или пустой - генерируется исключение.</param>
        /// <returns></returns>
        public static Boolean ContainsOnlyAllowed(String Input, Char[] AllowedSymbols)
        {
            if (Input.IsStringNullOrEmpty() == true) { throw new ArgumentException(ContainsHelpers._ExceptionString_NullOrEmptyString, "Input"); }
            if (AllowedSymbols.IsNullOrEmpty() == true) { throw new ArgumentException("Массив разрешенных символов не может быть NULL или пустой", "AllowedSymbols"); }

            Char[] input_array = Input.ToCharArray();
            foreach (char c in input_array)
            {
                if (c.IsIn(AllowedSymbols) == false)
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// Возвращает набор индексов начала и конца всех вхождений искомого шаблона в указанной строке, начиная поиск с указанного индекса. 
        /// Подстрока считается совпавшей с шаблоном тогда и только тогда, если начинается с указанного токена, оканчивается указанным токеном, и между токенами 
        /// содержит указанные обязательные и необязательные символы. Если между токенами содержатся какие-либо другие символы, 
        /// или же не содержится хотя бы одного из обязательных символов, то такая подстрока отбраковывается.
        /// </summary>
        /// <param name="Input">Входная строка, в которой происходит поиск шаблона. Если NULL или пустая, будет выброшено исключение.</param>
        /// <param name="StartToken">Начальный токен, которым должен начинаться искомый шаблон. Если NULL или пустой, будет выброшено исключение.</param>
        /// <param name="EndToken">Конечный токен, которым должен заканчиваться искомый шаблон. Если NULL или пустой, будет выброшено исключение.</param>
        /// <param name="StartIndex">Позиция (индекс), с которой включительно начинается анализ строки. Если меньше 0, будет приведён к 0. 
        /// Если больше длины строки, будет выброшено исключение.</param>
        /// <param name="RequiredInnerSymbols">Массив обязательных символов, все из которых должны присутствовать между начальным и конечным токеном. 
        /// Дублирующие символы игнорируются, учитываются только уникальные. Если NULL или пустой, предполагается, что обязательных символов нет.</param>
        /// <param name="OptionalInnerSymbols">Массив допустимых символов, которые могут, но не обязательны присутствовать между начальным и конечным токеном. 
        /// Дублирующие символы игнорируются, учитываются только уникальные. Если NULL или пустой, предполагается, что обязательных символов нет.</param>
        /// <param name="CompareOptions">Опции сравнения строк между собой</param>
        /// <returns>Словарь, где один элемент представляет индексы одного найденного токена: ключ содержит индекс начала токена, а значение - индекс его конца. 
        /// Если ни одного токена не найдено, возвращается пустой словарь.</returns>
        public static Dictionary<Int32, Int32> IndexesOfTemplate(String Input, String StartToken, String EndToken, Int32 StartIndex,
            Char[] RequiredInnerSymbols, Char[] OptionalInnerSymbols, StringComparison CompareOptions)
        {
            if (Input.IsStringNullOrEmpty() == true) { throw new ArgumentException("Входная строка не может быть NULL или пустой", "Input"); }
            if (StartToken.IsStringNullOrEmpty() == true) throw new ArgumentException("Начальный токен не может быть NULL или пустой строкой", "StartToken");
            if (EndToken.IsStringNullOrEmpty() == true) throw new ArgumentException("Конечный токен не может быть NULL или пустой строкой", "EndToken");
            if (StartIndex >= Input.Length) { throw new ArgumentOutOfRangeException("StartIndex", StartIndex, String.Format("Позиция начала поиска '{0}' превышает длину строки '{1}'", StartIndex, Input.Length)); }
            if (StartIndex < 0) { StartIndex = 0; }
            Int32 comp_value = (Int32)CompareOptions;
            if (comp_value < 0 || comp_value > 5) { throw new InvalidEnumArgumentException("CompareOptions", comp_value, typeof(StringComparison)); }
            if (RequiredInnerSymbols.IsNullOrEmpty() == true && OptionalInnerSymbols.IsNullOrEmpty() == true)
            {
                throw new ArgumentException("Массивы обязательных и допустимых символов не могут быть одновременно NULL или пустыми. " +
                  String.Format("RequiredInnerSymbols: {0}, OptionalInnerSymbols: {1}.", RequiredInnerSymbols.ToStringS("NULL", "пустой"), OptionalInnerSymbols.ToStringS("NULL", "пустой")));
            }
            Dictionary<Int32, Int32> output = new Dictionary<int, int>();

            Int32 start_token_length = StartToken.Length;
            Int32 end_token_length = EndToken.Length;
            HashSet<Char> unique_RequiredInnerSymbols = RequiredInnerSymbols.IsNullOrEmpty() == true ? new HashSet<Char>() : new HashSet<Char>(RequiredInnerSymbols);
            HashSet<Char> unique_OptionalInnerSymbols = OptionalInnerSymbols.IsNullOrEmpty() == true ? new HashSet<Char>() : new HashSet<Char>(OptionalInnerSymbols);
            Int32 offset = StartIndex;
            Dictionary<Char, Boolean> temp_dict = unique_RequiredInnerSymbols.Any() == true ? unique_RequiredInnerSymbols.ToDictionary((Char item) => item, (Char item) => false) : null;

            while (true)
            {
                Int32 start_index = Input.IndexOf(StartToken, offset, CompareOptions);
                if (start_index < 0) { break; }
                offset = start_index + start_token_length;
                Int32 end_index = Input.IndexOf(EndToken, offset, CompareOptions);
                if (end_index < 0) { break; }
#if Debug
                    String temp_substring = Input.SubstringWithEnd(offset, end_index);
#endif
                Boolean fail = false;
                for (Int32 i = offset; i < end_index; i++)
                {
                    Char ch = Input[i];

                    if (ch.IsIn(unique_RequiredInnerSymbols) == false && ch.IsIn(unique_OptionalInnerSymbols) == false)
                    {
                        fail = true;
                        break;
                    }
                    if (unique_RequiredInnerSymbols.Any() == true && ch.IsIn(unique_RequiredInnerSymbols) == true)
                    {
                        temp_dict[ch] = true;
                    }
                }
                if (fail == true || (temp_dict != null && temp_dict.All(item => item.Value == true) == false))
                {
                    continue;
                }
                offset = end_index + end_token_length - 1;
                output.Add(start_index, offset);

            }
            return output;
        }