/// <summary> /// Преобразовать строку в формат /// </summary> /// <param name="phrase">Строка</param> /// <param name="cases">Формат</param> /// <returns>Строка</returns> public static string CaseFormat(this string phrase, StringCase cases) { var splittedPhrase = phrase.Split(' ', '-', '.'); var sb = new StringBuilder(); switch (cases) { case StringCase.CamelCase: sb.Append(splittedPhrase[0].ToLower()); splittedPhrase[0] = string.Empty; break; case StringCase.PascalCase: sb = new StringBuilder(); break; } foreach (var splittedPhraseChars in splittedPhrase.Select(s => s.ToCharArray())) { if (splittedPhraseChars.Length > 0) { splittedPhraseChars[0] = ((new String(splittedPhraseChars[0], 1)).ToUpper().ToCharArray())[0]; } sb.Append(new String(splittedPhraseChars)); } return sb.ToString(); }
public StringCase Convert(string pascalCase) { StringCase result = new StringCase(); result.PascalCase = pascalCase; result.CamelCase = PascalToCamelCase.Convert(pascalCase); result.UnderscoreLowerCase = PascalToUnderscore.ConvertLower(pascalCase); result.UnderscoreUpperCase = PascalToUnderscore.ConvertUpper(pascalCase); result.SentenceCase = PascalToSentenceCase.Convert(pascalCase); return result; }
public static string Transform(string input, StringCase targetCase) { if (input.Length < 1) return input; switch (targetCase) { case StringCase.PascalCase: return input[0].ToString().ToUpper() + input.Substring(1); case StringCase.camelCase: return input[0].ToString().ToLower() + input.Substring(1); case StringCase.lowercase: return input.ToLower(); case StringCase.UPPERCASE: return input.ToUpper(); default: throw new Exception("Unknown string case!"); } }
public static string Wordify(this string input, StringCase casing = StringCase.Lower) { string output = input.Replace("_", " "); var r = new Regex("(?<=[a-z])(?<x>[A-Z])|(?<=.)(?<x>[A-Z])(?=[a-z])"); output = r.Replace(output, " ${x}"); switch (casing) { case StringCase.Lower: output = output.ToLower(); break; case StringCase.Title: output = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(output.ToLower()); break; } return output; }
public static string GenerateNameByParameter(IParameter parameter, string format, StringCase stringCase, string filterString) { string generateName = parameter.Name; switch (stringCase) { case StringCase.CamelCase: generateName = utils.SetCamelCase(generateName); break; case StringCase.PascalCase: generateName = utils.SetPascalCase(generateName); break; } char[] filterChar = filterString.ToCharArray(); foreach (char c in filterChar) { generateName = generateName.Replace(c.ToString(), ""); } return string.Format(format, generateName); }
public static string ToCase(this string s, StringCase strCase) { switch (strCase) { case StringCase.Lower: return(s.ToLower()); case StringCase.Upper: return(s.ToUpper()); case StringCase.UpperFirst: if (String.IsNullOrEmpty(s)) { return(s); } else { return(s.Substring(0, 1).ToUpper() + s.Substring(1)); } default: throw new Exception(); } }
/// <summary> /// Get the value of an enum as a string. /// </summary> /// <param name="val"> The enum to convert to a <see cref="string"/>. </param> /// <param name="case"> A <see cref="StringCase"/> indicating which case to return. Valid enumerations are StringCase.Lower and StringCase.Upper. </param> /// <exception cref="ArgumentNullException"> If the enum is null. </exception> /// <returns></returns> public static string GetName <TEnum>(this TEnum val, StringCase @case = StringCase.Default) where TEnum : struct { var name = Enum.GetName(val.GetType(), val); if (name == null) { return(null); } switch (@case) { case StringCase.Lower: return(name.ToLower()); case StringCase.Upper: return(name.ToUpper()); default: return(name); } }
/// <summary> /// 返回指定位数随机码,可以指定数字、大小写字母是否出现,可能包含除指定列表外所有字母和数字 /// </summary> /// <param name="length">长度</param> /// <param name="stringCase">大小写</param> /// <param name="excepts">例外</param> /// <returns>随机数</returns> public static string RandomCode(int length, StringCase stringCase, params char[] excepts) { IEnumerable <char> chars = new List <char>(); if (stringCase.HasFlag(StringCase.Digit)) { chars = chars.Concat(digitChars); } if (stringCase.HasFlag(StringCase.Lower)) { chars = chars.Concat(lowerChars); } if (stringCase.HasFlag(StringCase.Upper)) { chars = chars.Concat(upperChars); } return(RandomCode(length, chars.Where(c => !excepts.Contains(c)).ToList())); }
private string Caseify(string value, CultureInfo cultureInfo, StringCase stringCase) { if (string.IsNullOrEmpty(value)) { return(value); } switch (stringCase) { case StringCase.Upper: return(cultureInfo.TextInfo.ToUpper(value)); case StringCase.Lower: return(cultureInfo.TextInfo.ToLower(value)); case StringCase.Title: return(cultureInfo.TextInfo.ToTitleCase(value)); default: return(value); } }
/// <summary></summary> public override bool Render(IInternalContextAdapter context, TextWriter writer, INode node) { string text = node.GetChild(0).Literal; string[] args = text.Substring(1, text.Length - 2).Split(','); string[] keys = args[0].Split('.'); StringCase stringCase = StringCase.Default; if (args.Length == 2) { stringCase = (StringCase)Enum.Parse(typeof(StringCase), args[1]); } if (keys[0] == "Strings") { if (keys.Length == 2) { writer.Write(I18n.Strings[keys[1], stringCase]); } else if (keys.Length == 3) { writer.Write(I18n.Strings[keys[1], keys[2], stringCase]); } } else if (keys[0] == "Translates") { if (keys.Length == 2) { writer.Write(I18n.Translates[keys[1], stringCase]); } else if (keys.Length == 3) { writer.Write(I18n.Translates[keys[1], keys[2], stringCase]); } } return(true); }
/// <summary> /// 将参数转为类型 /// </summary> /// <typeparam name="T">类型</typeparam> /// <returns></returns> public T ToObject <T>(StringCase stringCase = StringCase.Snake) { var type = typeof(T); var obj = Activator.CreateInstance(type); var properties = type.GetProperties(); foreach (var item in properties) { var key = stringCase switch { StringCase.Camel => item.Name.ToCamelCase(), StringCase.Snake => item.Name.ToSnakeCase(), _ => item.Name }; _values.TryGetValue(key, out var value); if (value != null) { item.SetValue(obj, Convert.ChangeType(value, item.PropertyType)); } } return((T)obj); }
private string ToStringCase(string text, StringCase stringCase) { switch (stringCase) { case StringCase.Lower: return(text.ToLower()); case StringCase.FirstLower: return(StringHelper.ToFirstLower(text)); case StringCase.Upper: return(text.ToUpper()); case StringCase.FirstUpper: return(StringHelper.ToFirstUpper(text)); case StringCase.Title: return(Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(text.ToLower())); default: return(text); } }
public static string GetMD5(string plaintext, StringCase CASE) { byte[] plainbytes = Encoding.GetEncoding("UTF-8").GetBytes(plaintext); var cryptor = new MD5CryptoServiceProvider(); byte[] cipherbytes = cryptor.ComputeHash(plainbytes); var strBuilder = new StringBuilder(); for (int i = 0; i < cipherbytes.Length; i++) { if (CASE == StringCase.UPPERCASE) { strBuilder.Append(cipherbytes[i].ToString("X2")); } else { strBuilder.Append(cipherbytes[i].ToString("x2")); } } string ciphertext = strBuilder.ToString(); return(ciphertext); }
public static string Case(this string value, StringCase @case, CultureInfo cultureInfo = default) { if (cultureInfo == default) { cultureInfo = CultureInfo.InvariantCulture; } if (@case == StringCase.None) { return(value); } if (@case == StringCase.Upper) { return(value.ToUpper(cultureInfo)); } if (@case == StringCase.Lower) { return(value.ToLower(cultureInfo)); } return(value); }
public static string GenerateNameByParameter(IParameter parameter, string format, StringCase stringCase) { return(GenerateNameByParameter(parameter, format, stringCase, defaultFilterString)); }
/// <summary> /// Formats the string based on the capitalization specified /// </summary> /// <param name="Input">Input string</param> /// <param name="Case">Capitalization type to use</param> /// <returns>Capitalizes the string based on the case specified</returns> public static string ToString(this string Input, StringCase Case) { if (string.IsNullOrEmpty(Input)) return ""; if (Case == StringCase.FirstCharacterUpperCase) { char[] InputChars = Input.ToCharArray(); for (int x = 0; x < InputChars.Length; ++x) { if (InputChars[x] != ' ' && InputChars[x] != '\t') { InputChars[x] = char.ToUpper(InputChars[x], CultureInfo.InvariantCulture); break; } } return new string(InputChars); } else if (Case == StringCase.SentenceCapitalize) { string[] Seperator = { ".", "?", "!" }; string[] InputStrings = Input.Split(Seperator, StringSplitOptions.None); for (int x = 0; x < InputStrings.Length; ++x) { if (!string.IsNullOrEmpty(InputStrings[x])) { var TempRegex = new Regex(InputStrings[x]); InputStrings[x] = InputStrings[x].ToString(StringCase.FirstCharacterUpperCase); Input = TempRegex.Replace(Input, InputStrings[x]); } } return Input; } else if (Case == StringCase.TitleCase) { string[] Seperator = { " ", ".", "\t", System.Environment.NewLine, "!", "?" }; string[] InputStrings = Input.Split(Seperator, StringSplitOptions.None); for (int x = 0; x < InputStrings.Length; ++x) { if (!string.IsNullOrEmpty(InputStrings[x]) && InputStrings[x].Length > 3) { var TempRegex = new Regex(InputStrings[x].Replace(")", @"\)").Replace("(", @"\(").Replace("*", @"\*")); InputStrings[x] = InputStrings[x].ToString(StringCase.FirstCharacterUpperCase); Input = TempRegex.Replace(Input, InputStrings[x]); } } return Input; } return Input; }
public static string GenerateNameByProceduce(IProcedure procedure, string format, StringCase stringCase) { return GenerateNameByProceduce(procedure, format, stringCase, defaultFilterString); }
public static string GenerateNameByProceduce(IProcedure procedure, string format, StringCase stringCase, string filterString) { string generateName = procedure.Name; if (!string.IsNullOrEmpty(filterString)) { string[] filterStrings = filterString.Split((",").ToCharArray()); foreach (string s in filterStrings) { if (generateName.ToUpper().StartsWith(s.ToUpper())) { generateName = generateName.Substring(s.Length, generateName.Length - s.Length); } } } switch (stringCase) { case StringCase.CamelCase: generateName = utils.SetCamelCase(generateName); break; case StringCase.PascalCase: generateName = utils.SetPascalCase(generateName); break; } return string.Format(format, generateName); }
public static string GenerateNHibernateTypeByTableColumn(IColumn column, bool isCreateFKClassRefrence, string tableNameFormat, StringCase stringTableCase, string filterTableString) { string nHibernateType = GeneratePrivateMembersTypeByTableColumn(column, false, isCreateFKClassRefrence, tableNameFormat, stringTableCase, filterTableString); switch (column.LanguageType) { case "byte[]": if (column.DataTypeName.ToLower() == "timestamp") { return("Timestamp"); } else { return("Byte[]"); } ; case "bool": return("Boolean"); case "decimal": return("Decimal"); default: return(nHibernateType); } }
public static string GenerateNameByParameter(IParameter parameter, string format, StringCase stringCase) { return GenerateNameByParameter(parameter, format, stringCase, defaultFilterString); }
/// <summary> /// Formats the string based on the capitalization specified /// </summary> /// <param name="input">Input string</param> /// <param name="caseOfString">Capitalization type to use</param> /// <param name="provider">CultureInfo to use. Defaults to InvariantCulture.</param> /// <returns>Capitalizes the string based on the case specified</returns> public static string ToString(this string?input, StringCase caseOfString, CultureInfo?provider = null) { if (string.IsNullOrEmpty(input)) { return(string.Empty); } provider ??= CultureInfo.InvariantCulture; if (caseOfString == StringCase.FirstCharacterUpperCase) { var InputChars = input.ToCharArray(); for (var x = 0; x < InputChars.Length; ++x) { if (InputChars[x] != ' ' && InputChars[x] != '\t') { InputChars[x] = provider.TextInfo.ToUpper(InputChars[x]); break; } } return(new string(InputChars)); } if (caseOfString == StringCase.SentenceCapitalize) { string[] Seperator = { ".", "?", "!" }; var InputStrings = input.Split(Seperator, StringSplitOptions.None); for (var x = 0; x < InputStrings.Length; ++x) { if (!string.IsNullOrEmpty(InputStrings[x])) { var TempRegex = new Regex(InputStrings[x]); InputStrings[x] = InputStrings[x].ToString(StringCase.FirstCharacterUpperCase); input = TempRegex.Replace(input, InputStrings[x]); } } return(input); } if (caseOfString == StringCase.TitleCase) { string[] Seperator = { " ", ".", "\t", Environment.NewLine, "!", "?" }; var InputStrings = input.Split(Seperator, StringSplitOptions.None); for (var x = 0; x < InputStrings.Length; ++x) { if (!string.IsNullOrEmpty(InputStrings[x]) && InputStrings[x].Length > 3) { var TempRegex = new Regex(InputStrings[x] .Replace(")", @"\)", StringComparison.Ordinal) .Replace("(", @"\(", StringComparison.Ordinal) .Replace("*", @"\*", StringComparison.Ordinal)); InputStrings[x] = InputStrings[x].ToString(StringCase.FirstCharacterUpperCase); input = TempRegex.Replace(input, InputStrings[x]); } } return(input); } if (caseOfString == StringCase.CamelCase) { input = input.Replace(" ", "", StringComparison.Ordinal); return(char.ToLower(input[0], CultureInfo.InvariantCulture) + input.Remove(0, 1)); } return(input); }
public static string GenerateNameByView(IView view, string format, StringCase stringCase) { return(GenerateNameByView(view, format, stringCase, defaultFilterString)); }
internal static Tuple <char, char> ToCase(Tuple <char, char> tuple, StringCase stringCase) { return(Tuple.Create(tuple.Item1.ToCase(stringCase), tuple.Item2.ToCase(stringCase))); }
public StringCaseValidatorAttribute(StringCase textCase) { this.textCase = textCase; }
public static string GenerateNameByTableColumn(IColumn column, string format, StringCase stringCase, string filterString) { string generateName = column.Name; switch (stringCase) { case StringCase.CamelCase: generateName = utils.SetCamelCase(generateName); break; case StringCase.PascalCase: generateName = utils.SetPascalCase(generateName); break; } char[] filterChar = filterString.ToCharArray(); foreach (char c in filterChar) { generateName = generateName.Replace(c.ToString(), ""); } return(string.Format(format, generateName)); }
public static string GenerateNameByTableColumn(IColumn column, string format, StringCase stringCase) { return(GenerateNameByTableColumn(column, format, stringCase, defaultFilterString)); }
/// <summary> /// Gets a string of random lorin epsum having a length equal to or less than the max length argument along with the specified string case applied. /// </summary> /// <param name="maxLength">Maximum length of the returned string.</param> /// <param name="stringCase">The string case rule to apply.</param> /// <returns>String of random lorin epsum having a length equal to or less than the max length argument along with the specified string case applied.</returns> public String GetString(Int32 maxLength, StringCase stringCase) { return(GetString(maxLength, stringCase, false)); }
public async void ChangeCase(int startindex, int length, StringCase stringCase) { Text = await Task.Run(() => { string substring = Text.Substring(SelectionStart, SelectionLength); switch (stringCase) { case StringCase.Upper: substring = substring.ToUpper(); break; case StringCase.Lower: substring = substring.ToLower(); break; } string text = Text.Remove(SelectionStart, SelectionLength); return text.Insert(SelectionStart, substring); }); }
public EncryptAttribute(string encryptionSaltKey, EncryptionMethod encryptionMethod, StringCase @case = StringCase.None) { EncryptionSaltKey = encryptionSaltKey; EncryptionMethod = encryptionMethod; Case = @case; }
/// <summary> /// Gets aliased "player" strings (pronouns and a few other things) /// </summary> private string GetPlayerAlias(string alias) { //check the case StringCase aliasCase = StringCase.Unspecified; if (char.IsLower(alias[0])) { aliasCase = StringCase.LowerCase; } else if (char.IsLower(alias[1])) { aliasCase = StringCase.TitleCase; } else { aliasCase = StringCase.UpperCase; } if (alias.EndsWith("|keepcase", StringComparison.OrdinalIgnoreCase)) { aliasCase = StringCase.Unspecified; alias = alias.Substring(0, alias.IndexOf('|')); } CharacterModel player = GameState.Instance.PlayerRpgState; string uncasedResult = null; if (alias.Equals("name", StringComparison.OrdinalIgnoreCase)) { uncasedResult = player.DisplayName; } else if (alias.Equals("shortname", StringComparison.OrdinalIgnoreCase)) { uncasedResult = player.DisplayName; //will likely return something different later } else if (alias.Equals("race", StringComparison.OrdinalIgnoreCase)) { uncasedResult = "Human"; } else { //it's a lookup! //figure out which list we need string listName; switch (player.Gender) { case Sex.Undefined: listName = "ALIAS_NOGENDER"; break; case Sex.Female: listName = "ALIAS_FEMALE"; break; case Sex.Male: listName = "ALIAS_MALE"; break; case Sex.Other: listName = "ALIAS_NEUTRAL"; break; default: throw new NotSupportedException($"Unknown gender \"{player.Gender}\""); } uncasedResult = Sub.Replace(alias, listName, true); } //conform the casing string casedResult = null; switch (aliasCase) { case StringCase.LowerCase: casedResult = uncasedResult.ToLower(CultureInfo.InvariantCulture); break; case StringCase.UpperCase: casedResult = uncasedResult.ToUpper(CultureInfo.InvariantCulture); break; case StringCase.TitleCase: casedResult = uncasedResult.ToTitleCase(); break; default: casedResult = uncasedResult; break; } return(casedResult); }
public static string GeneratePrivateMembersTypeByTableColumn(IColumn column, bool enableNullType, bool isCreateFKClassRefrence, string tableNameFormat, StringCase stringTableCase, string filterTableString) { if (isCreateFKClassRefrence && column.IsInForeignKey && !column.IsInPrimaryKey) { return(TableGenerationHelper.GenerateNameByTable(column.ForeignKeys[0].PrimaryTable, tableNameFormat, stringTableCase, filterTableString)); } if (enableNullType) { foreach (string notNullableType in notNullableTypes) { if (column.LanguageType.ToLower() == notNullableType) { return(notNullableType); } } if (column.IsNullable) { return(column.LanguageType + "?"); } else { return(column.LanguageType); } } else { return(column.LanguageType); } }
private async Task <IEnumerable <byte> > Encrypt(EncryptionMethod encryptionMethod, ICryptographicCredentials cryptographicCredentials, string value, StringCase @case) { switch (encryptionMethod) { case EncryptionMethod.Encryption: return(await _cryptographyProvider.Encrypt(cryptographicCredentials, value.Case(@case))); case EncryptionMethod.Hashing: return(_hashingProvider.PasswordDerivedBytes(value, cryptographicCredentials.Key, cryptographicCredentials.KeyDerivationPrf, cryptographicCredentials.Iterations, cryptographicCredentials.TotalNumberOfBytes)); default: throw new NotSupportedException(); } ; }
public static string GenerateNameByTable(ITable table, string format, StringCase stringCase) { return(GenerateNameByTable(table, format, stringCase, defaultFilterString)); }