Przedstawiam kolejną porcję przydatnych metod :)
Trim
Dodatkowe przeciążenie, które zwraca nie wiekszą ilość znaków niz maxLength.
1: public static string Trim(this string value, int maxLength)
2: {
3: if (!value.IsNullOrEmpty() && value.Length > maxLength)
4: {
5: return value.Substring(0, maxLength);
6: }
7: return value;
8: }
Przykład:
1: string a = "Ala ma kota";
2: string b = a.Trim(3); // b będzie zawierać 'Ala'
IsNullOrEmpty
To samo co string.IsNullOrEmpty, ale szybciej i wygodniej.
1: public static bool IsNullOrEmpty(this string value)
2: {
3: return string.IsNullOrEmpty(value);
4: }
Przykład:
1: string a = "";
2: bool result = a.IsNullOrEmpty();
Format
To samo co string.Format, ale szybciej i wygodniej.
1: public static string Format(this string value, params object[] args)
2: {
3: return String.Format(value, args);
4: }
5:
6: public static string Format(this string value, object arg0)
7: {
8: return String.Format(value, arg0);
9: }
10:
11: public static string Format(this string value, object arg0, object arg1)
12: {
13: return String.Format(value, arg0, arg1);
14: }
15:
16: public static string Format(this string value, object arg0, object arg1, object arg2)
17: {
18: return String.Format(value, arg0, arg1, arg2);
19: }
Przykład:
1: string f = "Ala {0} kota";
2: string x = f.Format("ma");
RegexReplace
Pozwala na szybkie zastąpienie ciągu znaków innym ciągiem znaków znalezionych na podstawie wyrażenia regularnego. Dodatkowo metoda ta zapamiętuje w pamięci podręcznej wcześniej utworzone wyrażenia.
1: private static Dictionary<string, Regex> regexCache = new Dictionary<string, Regex>();
2: public static string RegexReplace(this string value, string pattern, string replacement)
3: {
4: return RegexReplaceInternal(value, pattern, replacement, RegexOptions.Compiled);
5: }
6:
7: private static object rriLocker = new object();
8: private static string RegexReplaceInternal(string value, string pattern, string replacement, RegexOptions regexOptions)
9: {
10: bool isInCache;
11: lock (rriLocker)
12: {
13: isInCache = regexCache.ContainsKey(pattern);
14: }
15: if (isInCache)
16: {
17: return regexCache[pattern].Replace(value, replacement);
18: }
19: lock (rriLocker)
20: {
21: Regex rx = new Regex(pattern, RegexOptions.Compiled);
22: regexCache.Add(pattern, rx);
23: return rx.Replace(value, replacement);
24: }
25: }
26:
27: public static string RegexReplace(this string value, string pattern, string replacement, RegexOptions options)
28: {
29: return RegexReplaceInternal(value, pattern, replacement, RegexOptions.Compiled | options);
30: }
Przykład:
1: string a = " aaa ";
2: string b = a.RegexReplace("\s", ""); // b będzie zawierać 'aaa'
ToSlug
Tak ogólnie służy do budowania permalinków. :)
1: private static Regex slugAllowed = new Regex("[^a-zA-Z0-9\\s]", RegexOptions.Compiled | RegexOptions.CultureInvariant);
2: private static char[] slugPLChars = new char[] { 'ą', 'ę', 'ó', 'ś', 'ł', 'ż', 'ź', 'ć', 'ń' };
3: private static char[] slugProperChars = new char[] { 'a', 'e', 'o', 's', 'l', 'z', 'z', 'c', 'n' };
4:
5: public static string ToSlug(this string value)
6: {
7: StringBuilder sb = new StringBuilder(value.ToLower());
8: for (int i = 0; i < slugPLChars.Length; i++)
9: {
10: sb.Replace(slugPLChars[i], slugProperChars[i]);
11: }
12: string[] good = slugAllowed.Split(sb.ToString());
13: for (int i = 0; i < good.Length; i++)
14: {
15: if (good[i].Length > 0)
16: {
17: good[i] = good[i].Trim().RegexReplace(@"\s", "-") + "-";
18: }
19: }
20: return String.Join("", good).Trim('-');
21: }
Przykład:
1: string a = "Aluśka ma kocięta!!!";
2: string b = a.ToSlug(); //b będzie zawierać 'aluska-ma-kocieta'
ToPhysical
Zamienia ścieżkę wirtualną na fizyczną.
1: public static string ToPhysical(this string value)
2: {
3: return value.Replace("~/", HttpRuntime.AppDomainAppPath).Replace("/", "\\");
4: }
Przykład:
1: string a = "~/App_Data";
2: string b = a.ToPhysical(); //b będzie zawierać 'c:\projects\test\App_Data'
RemoveHtmlFormating
Czyści zadany ciąg znaków z formatowania HTML. Dodatkowo można zaznaczyć czy ma pozostawić HTMLowe znaki przejścia do nastepnej linii.
1: public static string RemoveHtmlFormating(this string value, bool leaveLineBreaks)
2: {
3: StringBuilder output = new StringBuilder(value);
4: output
5: .Replace("\r", "")
6: .Replace("\t", "")
7: .Replace(" /", "/")
8: .Replace("</p>", "\n")
9: .Replace("<br/>", "\n");
10:
11:
12: return RegexReplace(output.ToString(), "<.*?>", "").Replace("\n", leaveLineBreaks ? "<br/>" : "");
13: }
Przykład:
1: string a = "<p>Ala ma kota</p><p>Kot ma Alę</p>"
2: string b = a.RemoveHTMLFormating(true); // b będzie zawierać 'Ala ma kota<br/>Kot ma Alę'
Ostatni przykład nie napisałem sam, ale dosyć często używam i tutaj go prezentuję, bo jest naprawdę ciekawy (a sam kod działa naprawdę szybko).
FormatNamed
Metoda służy do zamiany w treści ciągu znaków na podstawie właściwości przekazanego obiektu.
1: private static string OutExpression(object source, string expression, bool ignoreNotFound)
2: {
3: string format = "";
4: string orygexpression = expression;
5:
6: int colonIndex = expression.IndexOf(':');
7: if (colonIndex > 0)
8: {
9: format = expression.Substring(colonIndex + 1);
10: expression = expression.Substring(0, colonIndex);
11: }
12:
13: try
14: {
15: if (String.IsNullOrEmpty(format))
16: {
17: return (DataBinder.Eval(source, expression) ?? "").ToString();
18: }
19: return DataBinder.Eval(source, expression, "{0:" + format + "}") ?? "";
20: }
21: catch (HttpException)
22: {
23: if (!ignoreNotFound)
24: {
25: throw new FormatException();
26: }
27: else
28: {
29: return orygexpression;
30: }
31: }
32: }
33:
34: public static string FormatNamed(this string format, object source)
35: {
36: return FormatNamed(format, source, false);
37: }
38:
39: public static string FormatNamed(this string format, object source, bool ignoreNotFound)
40: {
41: if (format == null)
42: {
43: throw new ArgumentNullException("format");
44: }
45:
46: StringBuilder result = new StringBuilder(format.Length * 2);
47:
48: using (var reader = new StringReader(format))
49: {
50: StringBuilder expression = new StringBuilder();
51: int @char = -1;
52:
53: State state = State.OutsideExpression;
54: do
55: {
56: switch (state)
57: {
58: case State.OutsideExpression:
59: @char = reader.Read();
60: switch (@char)
61: {
62: case -1:
63: state = State.End;
64: break;
65: case '{':
66: state = State.OnOpenBracket;
67: break;
68: case '}':
69: state = State.OnCloseBracket;
70: break;
71: default:
72: result.Append((char)@char);
73: break;
74: }
75: break;
76: case State.OnOpenBracket:
77: @char = reader.Read();
78: switch (@char)
79: {
80: case -1:
81: throw new FormatException();
82: case '{':
83: result.Append('{');
84: state = State.OutsideExpression;
85: break;
86: default:
87: expression.Append((char)@char);
88: state = State.InsideExpression;
89: break;
90: }
91: break;
92: case State.InsideExpression:
93: @char = reader.Read();
94: switch (@char)
95: {
96: case -1:
97: throw new FormatException();
98: case '}':
99: result.Append(OutExpression(source, expression.ToString(), ignoreNotFound));
100: expression.Length = 0;
101: state = State.OutsideExpression;
102: break;
103: default:
104: expression.Append((char)@char);
105: break;
106: }
107: break;
108: case State.OnCloseBracket:
109: @char = reader.Read();
110: switch (@char)
111: {
112: case '}':
113: result.Append('}');
114: state = State.OutsideExpression;
115: break;
116: default:
117: throw new FormatException();
118: }
119: break;
120: default:
121: throw new InvalidOperationException("Invalid state.");
122: }
123: } while (state != State.End);
124: }
125:
126: return result.ToString();
127: }
128:
129: private enum State
130: {
131: OutsideExpression,
132: OnOpenBracket,
133: InsideExpression,
134: OnCloseBracket,
135: End
136: }
Przykład:
1: class Foo
2: {
3: public string Kto {get; set;}
4: public string Co {get; set;}
5: }
6:
7: Foo f = new Foo { Kto = "Ala", Co = "kota" };
8: string a = "{Kto} ma {Co}";
9: string b = a.FormatNamed(f); //b będzie zawierać 'Ala ma kota'
Źródło: http://haacked.com/archive/0001/01/01/named-formats-redux.aspx
RSS