Пример #1
0
        /// <summary>
        /// 문자열에서 N 번째 찾을 sub string의 인덱스 (인덱스는 0부터 시작합니다.) 를 반환합니다.
        /// </summary>
        /// <param name="s">원본 문자열</param>
        /// <param name="sub">찾을 문자열</param>
        /// <param name="nth">nth 번째 검색</param>
        /// <param name="ignoreCase">대소문자 구분 여부</param>
        /// <param name="culture">문화권</param>
        /// <returns>찾은 위치, 검색 실패시에는 -1을 반환, 인덱스는 0부터 시작합니다.</returns>
        public static int IndexOfN(this string s, string sub, int nth, bool ignoreCase = true, CultureInfo culture = null) {
            if(IsEmpty(s) || IsEmpty(sub))
                return -1;

            culture = culture.GetOrInvaliant();

            string sourceStr, subStr;

            if(ignoreCase) {
                sourceStr = s.ToUpper(culture);
                subStr = sub.ToUpper(culture);
            }
            else {
                sourceStr = s;
                subStr = sub;
            }

            int index = 0;
            int length = sourceStr.Length;
            int sublen = subStr.Length;

            for(int i = 0; i < nth; i++) {
                index = sourceStr.IndexOf(subStr, index, length - index, StringComparison.Ordinal);

                if(index < 0)
                    return -1;

                if(i == (nth - 1))
                    return index;

                index += sublen;
                if(index >= length)
                    break;
            }

            return -1;
        }
Пример #2
0
        /// <summary>
        /// 문자열을 <see cref="System.Globalization.CultureInfo.CurrentCulture"/>를 이용하여 비교한다.
        /// </summary>
        /// <remarks>
        /// string.Compare 에 관련된 많은 함수들이 제공되므로 더 자세한 제어는 그 함수를 이용하세요.
        /// </remarks>
        /// <param name="s1">비교 문자열 1</param>
        /// <param name="s2">비교 문자열 2</param>
        /// <param name="ignoreCase">대소문자 구분 여부</param>
        /// <param name="culture">문화권</param>
        /// <returns>s1과 s2가 같다면 0, s1 &gt; s2 면 양수, s1 &lt; s2 이면 음수</returns>
        public static int Compare(this string s1, string s2, bool ignoreCase = true, CultureInfo culture = null) {
            culture = culture.GetOrInvaliant();
#if !SILVERLIGHT
            return string.Compare(s1, s2, ignoreCase, culture);
#else
			return string.Compare(s1, s2, CultureInfo.InvariantCulture, (ignoreCase) ? CompareOptions.IgnoreCase : CompareOptions.None);
#endif
        }
Пример #3
0
        /// <summary>
        /// 원본 문자열에서 oldPattern에 해당하는 문자열을 newPattern의 문자열로 교체한다.
        /// </summary>
        /// <param name="S">원본 문자열</param>
        /// <param name="oldPattern">바뀔 문자열</param>
        /// <param name="newPattern">새로운 문자열</param>
        /// <param name="ignoreCase">대소문자 구분 여부</param>
        /// <param name="culture"><c>CultureInfo</c></param>
        /// <returns>바뀐 문자열</returns>
        public static string Replace(this string S, string oldPattern, string newPattern, bool ignoreCase = true,
                                     CultureInfo culture = null) {
            if(S.IsEmpty())
                return S;

            oldPattern.ShouldNotBeEmpty("oldPattern"); // 공백일 수도 있으므로

            culture = culture.GetOrInvaliant();

            string searchStr, pattern;
            var result = new StringBuilder(S.Length * 2);

            if(ignoreCase) {
                searchStr = S.ToUpper(culture);
                pattern = oldPattern.ToUpper(culture);
            }
            else {
                searchStr = S;
                pattern = oldPattern;
            }

            var startIndex = 0;
            var length = S.Length;
            var offset = startIndex;

            do {
                startIndex = searchStr.IndexOf(pattern, offset, StringComparison.Ordinal);

                if(startIndex < 0) {
                    result.Append(S.Substring(offset, length - offset));
                    break;
                }

                if(startIndex - offset > 0)
                    result.Append(S.Substring(offset, startIndex - offset));

                result.Append(newPattern);

                offset = startIndex + pattern.Length;
            } while(startIndex >= 0);

            return result.ToString();
        }
Пример #4
0
        /// <summary>
        /// 지정된 문자열에 지정된 패턴이 검색되는 횟수를 반환한다.
        /// </summary>
        /// <param name="text">대상 문자열</param>
        /// <param name="pattern">검색 문자열 패턴</param>
        /// <param name="ignoreCase">대소문자 구분 여부</param>
        /// <param name="culture">특정 CultureInfo</param>
        /// <returns>검색 횟수</returns>
        public static int WordCount(string text, string pattern, bool ignoreCase = true, CultureInfo culture = null) {
            if(IsEmpty(text) || IsEmpty(pattern))
                return 0;

            culture = culture.GetOrInvaliant();

            StringComparison comparision;

            if(ignoreCase)
                comparision = (culture == CultureInfo.InvariantCulture)
                                  ? StringComparison.InvariantCultureIgnoreCase
                                  : StringComparison.CurrentCultureIgnoreCase;
            else
                comparision = (culture == CultureInfo.InvariantCulture)
                                  ? StringComparison.InvariantCulture
                                  : StringComparison.CurrentCulture;

            int count = 0;
            int index = 0;
            int pattenLength = pattern.Length;
            int maxLength = text.Length - pattenLength;

            do {
                index = text.IndexOf(pattern, index, comparision);

                if(index < 0)
                    break;

                count++;
                index += pattenLength;
            } while(index <= maxLength);

            return count;
        }
Пример #5
0
        /// <summary>
        /// 지정된 문자열을 지정된 패턴을 구분자로 하여 문자열 배열로 만든다.
        /// </summary>
        /// <param name="s">대상 문자열</param>
        /// <param name="pattern">구분할 문자열</param>
        /// <param name="ignoreCase">대소문자 구분 여부 </param>
        /// <param name="culture"><c>CultureInfo</c></param>
        /// <returns>문자열 1차원 배열</returns>
        public static string[] Split(this string s, string pattern, bool ignoreCase = true, CultureInfo culture = null) {
            if(IsEmpty(s))
                return new string[0];

            if(IsEmpty(pattern))
                return new[] { s };

            culture = culture.GetOrInvaliant();

            string searchStr, searchPattern;

            if(ignoreCase) {
                searchStr = s.ToUpper(culture);
                searchPattern = pattern.ToUpper(culture);
            }
            else {
                searchStr = s;
                searchPattern = pattern;
            }

            //StringList sl = new StringList();

            var sl = new List<string>();

            int startIndex;
            int offset = 0;
            int length = s.Length;

            do {
                startIndex = searchStr.IndexOf(searchPattern, offset, StringComparison.Ordinal);

                if(startIndex < 0) {
                    sl.Add(s.Substring(offset, length - offset));
                    break;
                }

                if(startIndex - offset > 0)
                    sl.Add(s.Substring(offset, startIndex - offset));

                offset = startIndex + pattern.Length;
            } while(startIndex > 0);

            return sl.ToArray();
        }