/// <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));
}
