/// <summary> /// The format x path. /// </summary> /// <param name="resolver"> /// The resolver. /// </param> /// <param name="nodes"> /// The nodes. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string FormatXPath(IXmlNamespaceResolver resolver, params string[] nodes) { if (nodes == null) { return(string.Empty); } StringBuilder builder = null; var leftString = RetrieveDefaultNamespacePrefix(resolver); foreach (var str2 in nodes) { if (TStringHelper.IsNullOrWhiteSpace(str2)) { builder = TStringHelper.CombineStrings(builder, "/"); } else if (str2.IndexOf(':') >= 0) { var delimiter = "/"; builder = TStringHelper.CombineStrings(builder, str2, delimiter); } else { var str4 = "/"; var str5 = ":"; builder = TStringHelper.CombineStrings(builder, TStringHelper.CombineStrings(leftString, str2, str5), str4); } } return(TStringHelper.StringToEmpty(builder)); }
/// <summary> /// The calculate and check hash. /// </summary> /// <param name="filePath"> /// The file path. /// </param> /// <param name="savedHash"> /// The saved hash. /// </param> /// <param name="expectedHash"> /// The expected hash. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public static bool CalculateAndCheckHash(string filePath, out string savedHash, out string expectedHash) { using (var stream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { var flag = DoCalculateAndCheckHash(stream, out savedHash, out expectedHash); savedHash = TStringHelper.StringToEmpty(savedHash).ToUpper(); expectedHash = TStringHelper.StringToEmpty(expectedHash).ToUpper(); return(flag); } }
/// <summary> /// The calculate and save hash. /// </summary> /// <param name="filePath"> /// The file path. /// </param> /// <param name="hash"> /// The hash. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public static bool CalculateAndSaveHash(string filePath, out string hash) { FileSystemPhysical.FileMakeWritable(filePath); using (var stream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read)) { var flag = DoCalculateAndSaveHash(stream, out hash); hash = TStringHelper.StringToEmpty(hash).ToUpper(); return(flag); } }
/// <summary> /// The retrieve request string. /// </summary> /// <param name="type"> /// The type. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string RetrieveRequestString(DataEventType type) { var str = RetrieveTransactionCode(type); if (string.IsNullOrEmpty(str)) { return(null); } var delimiter = "/"; return(TStringHelper.CombineStrings(str, RetrieveTranscauseCode(type), delimiter)); }
/// <summary> /// The calculate and check hash. /// </summary> /// <param name="stream"> /// The stream. /// </param> /// <param name="savedHash"> /// The saved hash. /// </param> /// <param name="expectedHash"> /// The expected hash. /// </param> /// <param name="resetPosition"> /// The reset position. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public static bool CalculateAndCheckHash( Stream stream, out string savedHash, out string expectedHash, bool resetPosition = true) { expectedHash = savedHash = null; var flag = DoResetPosition(stream, resetPosition) && DoCalculateAndCheckHash(stream, out savedHash, out expectedHash); savedHash = TStringHelper.StringToEmpty(savedHash).ToUpper(); expectedHash = TStringHelper.StringToEmpty(expectedHash).ToUpper(); return(flag); }
/// <summary> /// The bytes to hex string. /// </summary> /// <param name="bytes"> /// The bytes. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string BytesToHexString(byte[] bytes) { StringBuilder builder = null; if (bytes != null) { foreach (var num in bytes) { string delimiter = null; builder = TStringHelper.CombineStrings(builder, num.ToString("x2").ToUpper(), delimiter); } } return(TStringHelper.StringToEmpty(builder)); }
/// <summary> /// The do read config value. /// </summary> /// <param name="name"> /// The name. /// </param> /// <param name="value"> /// The value. /// </param> /// <param name="rawRead"> /// The raw read. /// </param> /// <typeparam name="T"> /// </typeparam> /// <returns> /// The <see cref="bool"/>. /// </returns> private static bool DoReadConfigValue <T>(string name, ref T value, bool rawRead) { Func <Match, int> func = null; try { var bTrimFirst = true; var input = TStringHelper.StringToNull(AppSettings[name], bTrimFirst); if (input != null) { if (!rawRead) { var matchCollection = regexEnvironmentVariable.Matches(input); if ((matchCollection != null) && (matchCollection.Count > 0)) { var builder = new StringBuilder(input); if (func == null) { func = row => row.Index; } foreach (var match in matchCollection.EnumerateMatches().OrderByDescending(func)) { var str2 = match.Groups[1].Value; var str3 = !string.IsNullOrEmpty(str2) ? TStringHelper.StringToEmpty(Environment.GetEnvironmentVariable(str2)) : string.Empty; builder.Remove(match.Index, match.Length); builder.Insert(match.Index, str3); } input = builder.ToString(); } } value = ConversionHelper.StringToValue <T>(input); return(true); } } catch { } return(false); }
/// <summary> /// The retrieve attribute. /// </summary> /// <param name="xmlNode"> /// The xml node. /// </param> /// <param name="attributeName"> /// The attribute name. /// </param> /// <param name="trimToNull"> /// The trim to null. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string RetrieveAttribute(this XElement xmlNode, string attributeName, bool trimToNull = false) { var attribute = xmlNode.Attribute(attributeName); if (attribute == null) { return(null); } if (!trimToNull) { return(attribute.Value); } var bTrimFirst = true; return(TStringHelper.StringToNull(attribute.Value, bTrimFirst)); }
// разрешить все ссылки на имена обрабатываемых полей // public void ResolveAllowedFields(PolicySearchFieldNameResolver resolver) // { // if (converters != null) // { // foreach (var converter in converters) // converter.AllowedFields.ResolveFields(resolver); // } // } // разрешить все ссылки на имена обрабатываемых полей // public void ResolveAllowedFields() // { // ResolveAllowedFields(FieldNameResolver); // } // провести подготовку строки, задав тонкие настройки /// <summary> /// The prepare string. /// </summary> /// <param name="s"> /// The s. /// </param> /// <param name="field"> /// The field. /// </param> /// <param name="flagged"> /// The flagged. /// </param> /// <param name="emptyToNull"> /// The empty to null. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> /// <exception cref="InvalidCastException"> /// </exception> public string PrepareString( string s, FieldTypes field = FieldTypes.Undefined, bool flagged = false, bool emptyToNull = false) { if (s != null) { /* * следует учитывать, что после преобразований какие-то буквы могут исчезнуть, а какие-то добавиться * в результате может сложиться новая последовательность символов, которая сама по себе подлежит преобразованию * наша цель: получить некий "конечный" результат, то есть такой, который уже не будет меняться, если к нему снова и снова применить все те же преобразования * * для этого будем повторять преобразования в цикле до тех пор, пока хоть что-то в строке меняется (разумеется, с защитой от зацикливания) * поначалу предполагалось сделать кеш готовых значений, но тесты показали, что в этом нет особого смысла, потому что наличие цикла добавило всего 2-3% времени на обработку файла */ ushort cycles = 0; var original_s = s; do { // текущее значение строки var saved_s = s; // преобразование к верхнему регистру if (GlobalUpper) { s = s.ToUpper(); } // применить настраиваемые преобразования if (converters != null) { foreach (var converter in converters) { s = converter.Convert(s, field, flagged); } } // убрать боковые пробелы if (GlobalTrim) { s = s.Trim(); } // убрать лишние пробелы if (GlobalCompact) { s = TStringHelper.CompactString(s); } // прерываем цикл, когда никаких изменений в строке больше нет if (string.Compare(s, saved_s, StringComparison.Ordinal) == 0) { break; } // защита от зацикливания if (++cycles > 10000) { throw new InvalidCastException( string.Format( "TextRules.PrepareString: зацикливание! field: {0}, flagged: {1}, string: {2}", field, flagged, original_s)); } }while (true); // привести пустую строку к null if (emptyToNull) { s = TStringHelper.StringToNull(s); } } return(s); }
// public static void SerializeObject(Stream stream, object obj, IXmlNamespaceResolver resolver = new IXmlNamespaceResolver()) // { // XmlSerializer serializer = new XmlSerializer(obj.GetType()); // XmlSerializerNamespaces namespaces = ResolveNamespacesForSerializer(resolver, false); // if (namespaces != null) // { // serializer.Serialize(stream, obj, namespaces); // } // else // { // serializer.Serialize(stream, obj); // } // } // public static void SerializeObject(XmlWriter xmlWriter, object obj, IXmlNamespaceResolver resolver = new IXmlNamespaceResolver()) // { // XmlSerializer serializer = new XmlSerializer(obj.GetType()); // XmlSerializerNamespaces namespaces = ResolveNamespacesForSerializer(resolver, false); // if (namespaces != null) // { // serializer.Serialize(xmlWriter, obj, namespaces); // } // else // { // serializer.Serialize(xmlWriter, obj); // } // } /// <summary> /// The split x path. /// </summary> /// <param name="xpath"> /// The xpath. /// </param> /// <returns> /// The <see cref="IEnumerable"/>. /// </returns> /// <exception cref="ArgumentException"> /// </exception> public static IEnumerable <string> SplitXPath(this string xpath) { List <string> list = null; char ch; var bTrimFirst = true; xpath = TStringHelper.StringToNull(xpath, bTrimFirst); if (xpath == null) { return(list); } var length = xpath.Length; var startIndex = 0; var num3 = 0; var none = QuotationMark.None; Label_0023: ch = xpath[num3]; var ch2 = ch; if (ch2 <= '\'') { switch (ch2) { case '"': switch (none) { case QuotationMark.None: none = QuotationMark.DoubleQuotes; goto Label_00D1; case QuotationMark.Apostrophe: goto Label_00D1; case QuotationMark.DoubleQuotes: none = QuotationMark.None; goto Label_00D1; } goto Label_00D1; case '\'': switch (none) { case QuotationMark.None: none = QuotationMark.Apostrophe; goto Label_00D1; case QuotationMark.Apostrophe: none = QuotationMark.None; goto Label_00D1; } goto Label_00D1; } } else if (((ch2 == '/') || (ch2 == '\\')) && (none == QuotationMark.None)) { var str = xpath.Substring(startIndex, num3 - startIndex); if (string.IsNullOrEmpty(str) && (list != null)) { throw new ArgumentException("пустой узел в x-path выражении"); } if (list == null) { list = new List <string>(); } list.Add(str); startIndex = num3 + 1; } Label_00D1: if (++num3 < length) { goto Label_0023; } if (none != QuotationMark.None) { throw new ArgumentException("незакрытая кавычка в x-path выражении"); } if (list == null) { list = new List <string>(); } list.Add(xpath.Substring(startIndex, num3 - startIndex)); return(list); }
/// <summary> /// Initializes a new instance of the <see cref="StringMatchingBase"/> class. /// </summary> /// <param name="matcher"> /// The matcher. /// </param> protected StringMatchingBase(string matcher) { this.matcher = TStringHelper.StringToNull(matcher); }
/// <summary> /// The select file infos. /// </summary> /// <param name="folderPath"> /// The folder path. /// </param> /// <param name="searchMask"> /// The search mask. /// </param> /// <param name="searchMode"> /// The search mode. /// </param> /// <param name="sortMode"> /// The sort mode. /// </param> /// <returns> /// The <see cref="IEnumerable"/>. /// </returns> /// <exception cref="ArgumentException"> /// </exception> public static IEnumerable <FileInfo> SelectFileInfos( string folderPath, string searchMask = "", TreeCollectMode searchMode = 0, EntriesSortMode sortMode = 0) { IEnumerable <FileInfo> files; var bTrimFirst = true; folderPath = TStringHelper.StringToEmpty(folderPath, bTrimFirst); if (!FolderExists(folderPath)) { return(null); } var folderInfo = new DirectoryInfo(folderPath); switch (searchMode) { case TreeCollectMode.RootOnly: files = folderInfo.GetFiles(CorrectFileSearchMask(searchMask)); break; case TreeCollectMode.LeavesOnly: { var list = new List <FileInfo>(); DoCollectFinalFiles(list, folderInfo, CorrectFileSearchMask(searchMask)); files = list; break; } case TreeCollectMode.Everywhere: files = folderInfo.GetFiles(CorrectFileSearchMask(searchMask), SearchOption.AllDirectories); break; default: throw new ArgumentException(string.Format("режим поиска файлов не поддерживается: {0}", searchMode)); } switch (sortMode) { case EntriesSortMode.Unsorted: return(files); case EntriesSortMode.NameAscending: return(from f in files orderby f.FullName select f); case EntriesSortMode.NameDescending: return(from f in files orderby f.FullName descending select f); case EntriesSortMode.CreationPointAscending: return(from f in files orderby f.CreationTimeUtc select f); case EntriesSortMode.CreationPointDescending: return(from f in files orderby f.CreationTimeUtc descending select f); case EntriesSortMode.ModificationPointAscending: return(from f in files orderby f.LastWriteTimeUtc select f); case EntriesSortMode.ModificationPointDescending: return(from f in files orderby f.LastWriteTimeUtc descending select f); } throw new ArgumentException(string.Format("режим сортировки при поиске файлов не поддерживается: {0}", sortMode)); }
/// <summary> /// The join prefix. /// </summary> /// <param name="message"> /// The message. /// </param> /// <param name="prefix"> /// The prefix. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string JoinPrefix(string message, string prefix) { string delimiter = null; return(TStringHelper.CombineStrings(prefix, message, delimiter)); }
/// <summary> /// The retrieve data event type. /// </summary> /// <param name="transactionCode"> /// The transaction code. /// </param> /// <param name="transcauseCode"> /// The transcause code. /// </param> /// <returns> /// The <see cref="DataEventType"/>. /// </returns> public static DataEventType RetrieveDataEventType(string transactionCode, string transcauseCode) { switch (TStringHelper.StringToEmpty(transactionCode)) { case "ZA1": string str2; if (((str2 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str2 == "301")) { break; } return(DataEventType.IssueOrReissuancePolicyAnnounce); case "ZA7": return(DataEventType.NotificationOfReceiveAnnounce); case "A04": string str3; if (((str3 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str3 == "П01")) { break; } return(DataEventType.IssuePolicy); case "A08": switch (TStringHelper.StringToEmpty(transcauseCode)) { case "П01": return(DataEventType.IssuePolicy); case "П02": return(DataEventType.DeregisterPolicy); case "П03": return(DataEventType.RegisterPolicy); case "П04": return(DataEventType.ChangePolicyPartial); case "П05": return(DataEventType.ChangePolicyEmployment); case "П06": return(DataEventType.ChangePolicyComplete); } break; case "A03": string str5; if (((str5 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str5 == "П07")) { break; } return(DataEventType.DecommitPolicyENP); case "A13": string str6; if (((str6 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str6 == "П09")) { break; } return(DataEventType.RecommitPolicyENP); case "A24": string str7; if (((str7 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str7 == "П10")) { break; } return(DataEventType.ResolvePolicyDublicates); case "A37": string str8; if (((str8 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str8 == "П11")) { break; } return(DataEventType.ResolvePolicyCollisions); case "ZP1": return(DataEventType.QueryPersonInsurance); case "ZP2": return(DataEventType.QueryPersonsRegistrating); case "ZP3": return(DataEventType.QueryPersonsDeregistrating); case "ZP4": return(DataEventType.QueryPersonsDeadAbroad); case "ZP5": return(DataEventType.QueryDublicates); } return(DataEventType.Undefined); }
/// <summary> /// The retrieve request struct. /// </summary> /// <param name="type"> /// The type. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string RetrieveRequestStruct(DataEventType type) { var delimiter = "_"; return(TStringHelper.CombineStrings(RetrieveRequestCode(type), RetrieveRequestStructCode(type), delimiter)); }
/// <summary> /// The validation handler. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="args"> /// The args. /// </param> private void ValidationHandler(object sender, ValidationEventArgs args) { var errorDelimiter = XmlValidator.errorDelimiter; errorMessage = TStringHelper.CombineStrings(errorMessage, args.Message, errorDelimiter); }
/// <summary> /// The plain whitespaces. /// </summary> /// <param name="s"> /// The s. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string PlainWhitespaces(this string s) { return(TStringHelper.ReplaceAny(s, ' ', new[] { '\t', '\r', '\n' })); }
/// <summary> /// The retrieve short info. /// </summary> /// <returns> /// The <see cref="string" />. /// </returns> public string RetrieveShortInfo() { return(TStringHelper.CombineStrings(BeginPacket.RetrieveShortInfo(), EndPacket.RetrieveShortInfo(), ", ")); }