GSF.Core by Grid Protection Alliance

<PackageReference Include="GSF.Core" Version="2.1.373-beta" />

---

API Diff between 2.1.373-beta and 2.4.150-beta

107 Additions 417 Removals

GSF

• public static class BitExtensions
  • public static string ToBinaryString(this sbyte value)
  • public static string ToBinaryString(this byte value)
  • public static string ToBinaryString(this short value)
  • public static string ToBinaryString(this ushort value)
  • public static string ToBinaryString(this Int24 value)
  • public static string ToBinaryString(this UInt24 value)
  • public static string ToBinaryString(this int value)
  • public static string ToBinaryString(this uint value)
  • public static string ToBinaryString(this long value)
  • public static string ToBinaryString(this ulong value)
• public static class BitMath
• public static class CharExtensions
  • public static BitArray ConvertHexToBitArray(this char value)
  • public static int ConvertHexToInt(this char value)
  • public static bool IsHex(this char value)
  • public static char ToLower(this char value)
  • public static char ToUpper(this char value)
• public static class Common
  • public static ulong GetAvailablePhysicalMemory()
  • public static ulong GetTotalPhysicalMemory()
  • public static bool IsNumericType(TypeCode typeCode)
  • public static bool IsNumericType(Type type)
  • public static bool IsNumericType<T>()
  • public static bool IsNumericType(object item)
  • public static object NotNull(object value, object nonNullValue)
  • public static object TypeConvertFromString(string value, Type type)
  • public static object TypeConvertFromString(string value, Type type, CultureInfo culture)
• public class DateTimeRounding
• public enum EnabledState
• public static class EnumExtensions
  • public static string GetDescription(this Enum enumeration, bool defaultToName = true)
  • public static string GetDescription(this Enum enumeration)
• public interface IMergeable<T>
• public class NullableWeakReference : WeakReference
• public static class NumericExtensions
  • public static decimal Normalize(this decimal value)
• public static class OptimizationOptions
  • public static int RoutingBatchSize { get; }
• public class RadixCodec
• public class Range<T>
  • public bool Contains(T value)
  • public bool Contains(T value, IComparer<T> comparer)
  • public bool Contains(T value, Comparison<T> comparison)
  • public bool Contains(Range<T> range)
  • public bool Contains(Range<T> range, IComparer<T> comparer)
  • public bool Contains(Range<T> range, Comparison<T> comparison)
• public sealed class Range<TRange, TState>
• public static class Serialization
  • public static IEnumerable<SerializationEntry> GetValues(this SerializationInfo info)
• public static class StringExtensions
  • public static T ConvertToType<T>(this string value, CultureInfo culture)
  • public static object ConvertToType(this string value, Type type)
  • public static object ConvertToType(this string value, Type type, CultureInfo culture)
  • public static T ConvertToType<T>(this string value, Type type)
  • public static T ConvertToType<T>(this string value, Type type, CultureInfo culture)
  • public static StringComparer GetComparer(this StringComparison comparison)
  • public static int IndexOfNot(this string value, char[] anyOf, int startIndex = 0)
  • public static int IndexOfNot(this string value, char character, int startIndex = 0)
  • public static int IndexOfNot(this string value, Func<char, bool> characterTestFunction, int startIndex = 0)
  • public static int IndexOfPrevious(this string value, string testString, int startIndex = 0, bool matchCase = true)
  • public static int IndexOfPrevious(this string value, char testChar, int startIndex = 0)
  • public static int IndexOfPrevious(this string value, Func<char, bool> characterTestFunction, int startIndex = 0)
  • public static int IndexOfPreviousNot(this string value, char testChar, int startIndex = 0)
  • public static int IndexOfPreviousNot(this string value, char[] anyOf, int startIndex = 0)
  • public static int IndexOfPreviousNot(this string value, Func<char, bool> characterTestFunction, int startIndex = 0)
  • public static string Interpolate<T>(this string format, T parameters)
  • public static string Interpolate(this string format, IEnumerable<KeyValuePair<string, object>> parameters)
  • public static string QuoteUnwrap(this string value, char quoteChar = '"')
  • public static string QuoteUnwrap(this string value, char[] quoteChars)
  • public static string RemoveCharacter(this string value, char characterToRemove)
  • public static string RemoveLeadingString(this string value, string stringToRemove, bool matchCase = true)
  • public static string RemoveLeadingString(this string value, char charToRemove, bool matchCase = true)
  • public static string RemoveLeadingZeros(this string value, bool AssureParseDouble = false)
  • public static string RemoveTrailingString(this string value, string stringToRemove, bool matchCase = true)
  • public static string RemoveTrailingString(this string value, char charToRemove, bool matchCase = true)
  • public static int StringCount(this string value, string testString, int startIndex = 0, bool matchCase = true)
  • public static string SubstringEnd(this string value, int length)
  • public static string SubstringPrevious(this string value, int endIndex, int length)
• public struct Ticks : IComparable, IFormattable, IConvertible, IComparable<Ticks>, IComparable<long>, IComparable<DateTime>, IComparable<TimeSpan>, IEquatable<Ticks>, IEquatable<long>, IEquatable<DateTime>, IEquatable<TimeSpan>
  • public static Ticks RoundToSecondDistribution(Ticks timestamp, double samplesPerSecond, Ticks Baseline)
  • public static Ticks ToSecondDistribution(Ticks timestamp, double samplesPerSecond, Ticks baseline, int tolerance)
  • public double ToDays()
  • public double ToHours()
  • public double ToMinutes()
• public abstract class TimeTagBase : ISerializable, IComparable, IComparable<TimeTagBase>, IComparable<DateTime>, IEquatable<TimeTagBase>, IEquatable<DateTime>, IFormattable
  • public const string DefaultFormat = "yyyy-MM-dd HH:mm:ss.fff"
• public static class TypeExtensions
  • public static List<Type> LoadImplementations(this Type type, string binariesDirectory, bool excludeAbstractTypes, bool validateReferences = true, bool executeStaticConstructors = false)
  • public static List<Type> LoadImplementations(this Type type, string binariesDirectory, bool excludeAbstractTypes, bool validateReferences = true)

GSF.Collection

• public sealed class IndexedArray<T> : IEnumerable<T>, IEnumerable
  • public T this[int index] { get; set; }
  • public IndexedArray()

GSF.Collections

• public static class CollectionExtensions
  • public static bool AllParallel<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, ParallelOptions options = null)
  • public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, bool forwardSearch = true)
  • public static IEnumerable<T> GetColumn<T>(this T[,] source, int columnIndex)
  • public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static IEnumerable<T> GetRow<T>(this T[,] source, int rowIndex)
  • public static T Majority<T>(this IEnumerable<T> source, bool forwardSearch = true, IEqualityComparer<T> comparer = null)
  • public static T Majority<T>(this IEnumerable<T> source, T defaultValue, bool forwardSearch = true, IEqualityComparer<T> comparer = null)
  • public static TSource MajorityBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, bool forwardSearch = true, IEqualityComparer<TKey> comparer = null)
  • public static TSource MajorityBy<TSource, TKey>(this IEnumerable<TSource> source, TSource defaultValue, Func<TSource, TKey> keySelector, bool forwardSearch = true, IEqualityComparer<TKey> comparer = null)
  • public static T Majority<T>(this IEnumerable<T> source)
  • public static T Majority<T>(this IEnumerable<T> source, T defaultValue)
  • public static T[] Median<T>(this IEnumerable<T> source)
  • public static T Minority<T>(this IEnumerable<T> source, bool forwardSearch = true, IEqualityComparer<T> comparer = null)
  • public static T Minority<T>(this IEnumerable<T> source, T defaultValue, bool forwardSearch = true, IEqualityComparer<T> comparer = null)
  • public static TSource MinorityBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, bool forwardSearch = true, IEqualityComparer<TKey> comparer = null)
  • public static TSource MinorityBy<TSource, TKey>(this IEnumerable<TSource> source, TSource defaultValue, Func<TSource, TKey> keySelector, bool forwardSearch = true, IEqualityComparer<TKey> comparer = null)
  • public static T Minority<T>(this IEnumerable<T> source)
  • public static T Minority<T>(this IEnumerable<T> source, T defaultValue)
  • public static PagedList<T> ToPagedList<T>(this IEnumerable<T> source, int page, int pageSize, int count = -1)
  • public static PagedList<T> ToPagedList<T>(this IEnumerable<T> source, int page, int pageSize)
• public class ConcurrentIsolatedQueue<T>
• public class DynamicObjectPool<T>
• public class FileBackedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IDisposable
  • protected virtual void Dispose(bool disposing)
  • public void OpenRead()
• public class FileBackedHashSet<T> : ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IDisposable
  • protected virtual void Dispose(bool disposing)
  • public void OpenRead()
• public sealed class IndexedArray<T> : IEnumerable<T>, IEnumerable
• public static class ListExtensions
  • public static int RemoveWhere<T>(this List<T> list, Func<T, bool> shouldRemove)
  • public static void RemoveWhere<T>(this List<T> list, Func<T, bool> shouldRemove)
• public class NullableArray<T> where T : struct
• public class PagedList<T> : List<T>, IPagedList
  • public PagedList(IEnumerable<T> source, int page, int pageSize, int count = -1)
  • public PagedList(IEnumerable<T> source, int page, int pageSize)
• public class SortedQueue<TKey, TValue>

GSF.ComponentModel

• public sealed class DefaultValueExpressionAttribute : ValueExpressionAttributeBase
• public class EvaluationOrderException : Exception
• public interface IValueExpressionAttribute
• public interface IValueExpressionScope<T>
• public sealed class TypeConvertedValueExpressionAttribute : ValueExpressionAttributeBase
• public static class TypeRegistryExtensions
• public sealed class UpdateValueExpressionAttribute : ValueExpressionAttributeBase
• public abstract class ValueExpressionAttributeBase : Attribute, IValueExpressionAttribute
• public class ValueExpressionParser : ValueExpressionParser<object>
• public class ValueExpressionParser<T> : CompiledExpression<T>
• public abstract class ValueExpressionScopeBase<T> : IValueExpressionScope<T>

GSF.ComponentModel.DataAnnotations

• public sealed class AcronymValidationAttribute : RegularExpressionAttribute
• public sealed class EmailValidationAttribute : RegularExpressionAttribute
• public sealed class InitialValueScriptAttribute : Attribute
• public sealed class IsDeletedFlagAttribute : Attribute
• public sealed class LabelAttribute : Attribute
• public sealed class PrimaryLabelAttribute : Attribute
• public sealed class UrlValidationAttribute : RegularExpressionAttribute

GSF.Configuration

• public abstract class CategorizedSettingsBase<TCategorizedSettings> : CategorizedSettingsBase<TypeConvertedValueExpressionAttribute, TCategorizedSettings> where TCategorizedSettings : CategorizedSettingsBase
• public abstract class CategorizedSettingsBase<TValueExpressionAttribute, TCategorizedSettings> : CategorizedSettingsBase where TValueExpressionAttribute : Attribute, IValueExpressionAttribute where TCategorizedSettings : CategorizedSettingsBase
• public class ConnectionStringParser<TParameterAttribute> : ConnectionStringParser where TParameterAttribute : Attribute
  • public static TypeRegistry TypeRegistry { get; set; }

GSF.Console

• public class Arguments : IEnumerable<KeyValuePair<string, string>>, IEnumerable, ISerializable
  • public const string TokenRegex = "(?:(?<Open>\")(?:[^\\\\\"]*(?:\\\\.)*)*(?<Close-Open>\")(?(Open)(?!))|\\S)+"

GSF.Data

• public class AdoDataConnection : IDisposable
  • public IsolationLevel DefaultIsolationLevel { get; }
  • public IsolationLevel DefaultIsloationLevel { get; }
  • public object ExecuteScalar(Type returnType, string sqlFormat, object[] parameters)
  • public object ExecuteScalar(Type returnType, int timeout, string sqlFormat, object[] parameters)
  • public object ExecuteScalar(Type returnType, object defaultValue, string sqlFormat, object[] parameters)
  • public object ExecuteScalar(Type returnType, object defaultValue, int timeout, string sqlFormat, object[] parameters)
• public abstract class BulkDataOperationBase : IBulkDataOperation, IDisposable
• public class DataDeleter : BulkDataOperationBase
• public class DataInserter : BulkDataOperationBase
• public class DataUpdater : BulkDataOperationBase
• public class Field : IComparable
• public class Fields : IEnumerable<Field>, IEnumerable
• public class ForeignKeyField
• public class ForeignKeyFields : IEnumerable
• public interface IBulkDataOperation
• public enum ReferentialAction
• public class Schema
• public class Table : IComparable, IComparable<Table>
• public class Tables : IEnumerable<Table>, IEnumerable
• public enum TableType

GSF.Data.Model

• public sealed class AdditionalFieldSearchAttribute : Attribute
• public enum AffixPosition
• public sealed class AllowSearchAttribute : Attribute
• public sealed class AmendExpressionAttribute : Attribute
• public sealed class ClaimAttribute : Attribute
• public sealed class ConfigFileTableNamePrefixAttribute : Attribute
• public sealed class CSVExcludeFieldAttribute : Attribute
• public sealed class CustomViewAttribute : Attribute
• public sealed class DefaultSortOrderAttribute : Attribute
• public sealed class DeleteRolesAttribute : Attribute
• public sealed class EncryptDataAttribute : Attribute
• public sealed class FieldDataTypeAttribute : Attribute
• public sealed class GetRolesAttribute : Attribute
• public sealed class InitialValueAttribute : Attribute
  • public string InitialValue { get; }
  • public InitialValueAttribute(string initialValue)
• public sealed class IsDeletedFlagAttribute : Attribute
  • public string FieldName { get; }
  • public IsDeletedFlagAttribute(string fieldName)
• public interface ITableOperations
  • bool ApplyRootQueryRestrictionToDeletes { get; set; }
  • bool ApplyRootQueryRestrictionToUpdates { get; set; }
  • DataTable PrimaryKeyCache { get; set; }
  • RecordRestriction RootQueryRestriction { get; set; }
  • int AddNewOrUpdateRecord(object record)
  • void ApplyRecordDefaults(object record)
  • void ApplyRecordUpdates(object record)
  • void ClearPrimaryKeyCache()
  • int DeleteRecord(RecordRestriction restriction, bool? applyRootQueryRestriction = default)
  • int DeleteRecordWhere(string filterExpression, object[] parameters)
  • int DeleteRecord(RecordRestriction restriction)
  • bool FieldHasAttribute(string fieldName, Type attributeType)
  • object GetInterpretedFieldValue(string fieldName, object value)
  • IEnumerable GetPageOfRecords(object[] records, int page, int pageSize)
  • int GetPrimaryKeyCacheSize()
  • RecordRestriction GetSearchRestriction(string searchText)
  • bool IsSearchMatch(object record, string[] searchValues)
  • bool IsSearchMatch(object record, StringComparison comparison, string[] searchValues)
  • object NewRecord()
  • object QueryRecord(RecordRestriction restriction)
  • object QueryRecord(string orderByExpression, RecordRestriction restriction)
  • int QueryRecordCountWhere(string filterExpression, object[] parameters)
  • IEnumerable QueryRecords(RecordRestriction restriction)
  • IEnumerable QueryRecordsWhere(string filterExpression, object[] parameters)
  • object QueryRecordWhere(string filterExpression, object[] parameters)
  • object[] SearchRecords(string sortField, bool ascending, string searchText, StringComparison comparison = 5)
  • DataTable ToDataTable(IEnumerable records)
  • bool TryGetFieldAttribute(string fieldName, Type attributeType, out Attribute attribute)
  • int UpdateRecord(object record, RecordRestriction restriction = null, bool? applyRootQueryRestriction = default)
  • int UpdateRecord(object record, RecordRestriction restriction = null)
  • int UpdateRecordWhere(object record, string filterExpression, object[] parameters)
  • int UpdateRecordWhere(DataRow row, string filterExpression, object[] parameters)
• public sealed class NonRecordFieldAttribute : Attribute
• public sealed class ParentKeyAttribute : Attribute
• public sealed class PatchRolesAttribute : Attribute
• public sealed class PostRolesAttribute : Attribute
• public sealed class LabelAttribute : Attribute
  • public string Label { get; }
  • public LabelAttribute(string label)
• public sealed class PrimaryLabelAttribute : Attribute
  • public string FieldName { get; }
  • public PrimaryLabelAttribute(string fieldName)
• public class RecordRestriction
  • public object this[int index] { get; set; }
  • public RecordRestriction()
  • public static RecordRestriction Clone(RecordRestriction source)
  • public static RecordRestriction CombineAnd(RecordRestriction left, RecordRestriction right)
  • public static RecordRestriction CombineOr(RecordRestriction left, RecordRestriction right)
  • public static RecordRestriction op_Addition(RecordRestriction left, RecordRestriction right)
  • public static RecordRestriction op_BitwiseAnd(RecordRestriction left, RecordRestriction right)
  • public static RecordRestriction op_BitwiseOr(RecordRestriction left, RecordRestriction right)
  • public static bool op_Equality(RecordRestriction left, RecordRestriction right)
  • public static RecordRestriction op_Implicit(string value)
  • public static bool op_Inequality(RecordRestriction left, RecordRestriction right)
  • public RecordRestriction Clone()
  • public bool Equals(RecordRestriction other)
• public sealed class ReturnLimitAttribute : Attribute
• public sealed class RootQueryRestrictionAttribute : Attribute
• public sealed class SettingsCategoryAttribute : Attribute
• public enum StatementTypes
• public class TableOperations<T> : ITableOperations
  • public static TypeRegistry TypeRegistry { get; set; }
  • public bool ApplyRootQueryRestrictionToDeletes { get; set; }
  • public bool ApplyRootQueryRestrictionToUpdates { get; set; }
  • public AdoDataConnection Connection { get; }
  • public DataTable PrimaryKeyCache { get; set; }
  • public RecordRestriction RootQueryRestriction { get; set; }
  • public TableOperations(AdoDataConnection connection, IEnumerable<KeyValuePair<string, string>> customTokens = null)
  • public TableOperations(AdoDataConnection connection, Action<Exception> exceptionHandler, IEnumerable<KeyValuePair<string, string>> customTokens = null)
  • public static Action<T> ApplyRecordDefaultsFunction()
  • public static Action<T> ApplyRecordUpdatesFunction()
  • public static string GetTableName()
  • public static Func<DataRow, T> LoadRecordFunction()
  • public static Func<T> NewRecordFunction()
  • public int AddNewOrUpdateRecord(T record)
  • public TableOperations(AdoDataConnection connection)
  • public TableOperations(AdoDataConnection connection, Action<Exception> exceptionHandler)
  • public void ApplyRecordDefaults(T record)
  • public void ApplyRecordUpdates(T record)
  • public void ClearPrimaryKeyCache()
  • public int DeleteRecord(RecordRestriction restriction, bool? applyRootQueryRestriction = default)
  • public int DeleteRecordWhere(string filterExpression, object[] parameters)
  • public int DeleteRecord(RecordRestriction restriction)
  • public object GetInterpretedFieldValue(string fieldName, object value)
  • public IEnumerable<T> GetPageOfRecords(T[] records, int page, int pageSize)
  • public int GetPrimaryKeyCacheSize()
  • public bool IsSearchMatch(T record, string[] searchValues)
  • public bool IsSearchMatch(T record, StringComparison comparison, string[] searchValues)
  • public T NewRecord()
  • public T QueryRecord(RecordRestriction restriction)
  • public T QueryRecord(string orderByExpression, RecordRestriction restriction)
  • public int QueryRecordCountWhere(string filterExpression, object[] parameters)
  • public IEnumerable<T> QueryRecords(RecordRestriction restriction)
  • public IEnumerable<T> QueryRecordsWhere(string filterExpression, object[] parameters)
  • public T QueryRecordWhere(string filterExpression, object[] parameters)
  • public T[] SearchRecords(string sortField, bool ascending, string searchText, StringComparison comparison = 5)
  • public DataTable ToDataTable(IEnumerable<T> records)
  • public int UpdateRecord(T record, RecordRestriction restriction = null, bool? applyRootQueryRestriction = default)
  • public int UpdateRecord(T record, RecordRestriction restriction = null)
  • public int UpdateRecordWhere(T record, string filterExpression, object[] parameters)
  • public int UpdateRecordWhere(DataRow row, string filterExpression, object[] parameters)
• public enum TargetExpression
• public sealed class ViewOnlyAttribute : Attribute

GSF.Diagnostics

• public sealed class ChildProcessManager : IDisposable
• public sealed class LogEventPublisher
  • public bool ShouldRaiseMessageSupressionNotifications { get; set; }
  • public void Publish(MessageFlags flags, string message = null, string details = null, Exception exception = null)
• public sealed class LogEventPublisherDetails : IEquatable<LogEventPublisherDetails>
  • public readonly string AssemblyName
  • public readonly PublisherTypeDefinition TypeData
  • public LogEventPublisherDetails(PublisherTypeDefinition typeData, string eventName)
  • public readonly string TypeName
  • public LogEventPublisherDetails(Stream stream)
  • public LogEventPublisherDetails(string typeName, string assemblyName, string eventName)
  • public void Save(Stream stream)
• public sealed class LogFileWriter : IDisposable
  • public long LogSize { get; }
• public class LogFileWriterInMemory
• public static class Logger
  • public struct StackDetailsDisposal : IDisposable
  • public static bool ShouldSuppressFirstChanceLogMessages { get; }
  • public static bool ShouldSuppressLogMessages { get; }
  • public static IDisposable AppendStackMessages(LogStackMessages messages)
  • public static IDisposable AppendStackMessages(string key, string value)
  • public static StackDetailsDisposal AppendStackMessages(LogStackMessages messages)
  • public static StackDetailsDisposal AppendStackMessages(string key, string value)
  • public static IDisposable OverrideSuppressLogMessages()
  • public static IDisposable SuppressFirstChanceExceptionLogMessages()
  • public static IDisposable SuppressLogMessages()
  • public static void SwallowException(Exception ex, string message = null, string details = null, MessageFlags additionalFlags = 0)
• public sealed class LogMessage
  • public readonly int ManagedThreadID
  • public readonly int PreviousFirstChanceExceptionSequenceNumber
  • public string AssemblyName { get; }
  • public string EventName { get; }
  • public ImmutableList<string> RelatedTypes { get; }
  • public string TypeName { get; }
• public class LogPublisher
  • public int MaxDistinctEventPublisherCount { get; set; }
• public class LogStackMessages : IEquatable<LogStackMessages>
  • public int Count { get; }
  • public KeyValuePair<string, string> this[int index] { get; }
  • public string this[string key] { get; }
  • public LogStackMessages(string[] keyValuePairs)
  • public LogStackMessages(List<KeyValuePair<string, string>> messages)
  • public LogStackMessages ConcatenateWith(string key, string value)
  • public LogStackMessages Union(string key, string value)
  • public LogStackMessages Union(string[] keyValuePairs)
  • public LogStackMessages Union(LogStackMessages stackMessage)
• public class LogStackTrace : ImmutableObjectAutoBase<LogStackTrace>, IEquatable<LogStackTrace>
  • public readonly ReadOnlyCollection<LogStackFrame> Frames
  • public readonly ImmutableList<LogStackFrame> Frames
• public class PerformanceCounter : IDisposable
  • public Func<float, float> SampleAdjuster { get; set; }
  • public Func<float, bool> SampleFilter { get; set; }
• public class PerformanceMonitor : IDisposable, IProvideStatus
  • public const double DefaultSamplingInterval = 1000
  • public ReadOnlyCollection<PerformanceCounter> Counters { get; }
  • public string LifetimeStatus { get; }
  • public string Name { get; }
  • public double SamplingInterval { get; set; }
  • public string Status { get; }
  • public void AddCounter(string categoryName, string counterName, string instanceName)
  • public void AddCounter(string categoryName, string counterName, string instanceName, string aliasName)
  • public void AddCounter(string categoryName, string counterName, string instanceName, string aliasName, string valueUnit)
  • public void AddCounter(string categoryName, string counterName, string instanceName, string aliasName, string valueUnit, float valueDivisor, bool readOnly = true)
  • public void AddCounter(PerformanceCounter counter)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public PerformanceCounter FindCounter(string counterName)
  • public PerformanceCounter FindCounter(string categoryName, string counterName)
  • public PerformanceCounter[] FindCounters(string counterName)
  • public PerformanceCounter[] FindCounters(string categoryName, string counterName)
  • public void RemoveCounter(PerformanceCounter counter)
  • public void SampleCounters()
• public abstract class PerformanceMonitorBase : IDisposable, IProvideStatus
• public sealed class ProcessUtilizationCalculator : IDisposable
• public sealed class PublisherTypeDefinition : IEquatable<PublisherTypeDefinition>
• public class SystemPerformanceMonitor : PerformanceMonitorBase

GSF.IO

• public class BlockAllocatedMemoryStream : Stream
  • public const int DefaultBlockSize = 16384
  • protected byte[] Block { get; }
  • protected int BlockIndex { get; }
  • protected int BlockOffset { get; }
  • public int BlockSize { get; }
  • public BlockAllocatedMemoryStream(byte[] buffer, int blockSize)
  • public BlockAllocatedMemoryStream(byte[] buffer, int startIndex, int length, int blockSize)
  • public BlockAllocatedMemoryStream(int capacity, int blockSize)
  • protected void EnsureCapacity(long length)
• public static class FilePath
  • public static void ApplyInheritableDirectoryPermissions(string sourcePath, string targetPath)
  • public static void ApplyInheritableFilePermissions(string sourcePath, string targetPath)
  • public static void ApplyInheritablePermissions(string sourcePath, string targetPath)
  • public static void CopyDirectoryPermissions(string sourcePath, string targetPath)
  • public static void CopyFilePermissions(string sourcePath, string targetPath)
  • public static void CopyPermissions(string sourcePath, string targetPath)
  • public static IEnumerable<string> EnumerateDirectories(string path, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static IEnumerable<DirectoryInfo> EnumerateDirectories(DirectoryInfo directory, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static IEnumerable<string> EnumerateFiles(string path, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static IEnumerable<FileInfo> EnumerateFiles(DirectoryInfo directory, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static bool GetAvailableFreeSpace(string pathName, out long freeSpace, out long totalSize)
  • public static string[] GetDirectories(string path, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static DirectoryInfo[] GetDirectories(DirectoryInfo directory, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static string[] GetFileList(string path, Action<Exception> exceptionHandler = null)
  • public static T GetFileLock<T>(string fileName, Func<string, T> lockFunction, double secondsToWait = 5, int retryMilliseconds = 200)
  • public static string[] GetFileList(string path)
  • public static string[] GetFiles(string path, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static FileInfo[] GetFiles(DirectoryInfo directory, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static void ResetPermissions(string path)
• public sealed class FileProcessor : IDisposable
  • public static readonly string DefaultCachePath
  • public const string DefaultFolderExclusion = ""
  • public const int DefaultMaxFragmentation = 10
  • public IList<string> ActivelyEnumeratedPaths { get; }
  • public string CachePath { get; set; }
  • public int EnumerationThreads { get; }
  • public string FolderExclusion { get; set; }
  • public Func<string, bool> FilterMethod { get; set; }
  • public bool IsEnumerating { get; }
  • public TimeSpan LastCompactDuration { get; }
  • public DateTime LastCompactTime { get; }
  • public int MaxFragmentation { get; set; }
  • public bool OrderedEnumeration { get; set; }
  • public FileProcessor()
  • public FileProcessor(Guid processorID)
  • public bool MatchesFilter(string filePath)
  • public bool MatchesFolderExclusion(string folderPath)
  • public void ResetIndexAndStatistics()
• public class FileProcessorEventArgs : EventArgs
  • public bool AlreadyProcessed { get; }
  • public bool RaisedByFileWatcher { get; }
  • public int RetryCount { get; }
  • public FileProcessorEventArgs(string fullPath, bool raisedByFileWatcher, Func<int> retryCounter)
  • public FileProcessorEventArgs(string fullPath, bool alreadyProcessed)
• public class Outage : Range<DateTimeOffset>
  • public bool Equals(Outage other)
• public class OutageLog : ObservableCollection<Outage>, ISupportLifecycle, IDisposable, IProvideStatus
  • public int Count { get; }
  • public virtual bool Enabled { get; set; }
  • public List<Outage> Outages { get; }
  • public event EventHandler LogModified
  • public void Add(Outage outage)
  • public Outage First()
  • public ManualResetEventSlim Flush()
  • public bool Remove(Outage outage)
  • protected void InitiateRead()
  • protected void InitiateWrite()
  • protected virtual void OnProcessException(Exception ex)
• public class RunTimeLog : ISupportLifecycle, IDisposable, IProvideStatus
  • public TimeSpan UpTime { get; }

GSF.IO.Checksums

• public sealed class Crc32
  • public static uint Compute(byte[] buffer, int offset, int count)

GSF.Identity

• public sealed class UserInfo : ISupportLifecycle, IDisposable, IPersistSettings
  • public static readonly string BuiltInGroupName
  • public static readonly string NTAuthorityGroupName
  • public static readonly string NTServiceGroupName
  • public IPrincipal PassthroughPrincipal { get; set; }

GSF.Interop

• public static class WindowsApi
  • public class MEMORYSTATUSEX
  • public const string SE_SERVICE_LOGON_NAME = "SeServiceLogonRight"
  • public static void FlushFileBuffers(SafeFileHandle handle)
  • public static bool GlobalMemoryStatusEx(MEMORYSTATUSEX lpBuffer)

GSF.Net.Security

• public class CertificateGenerator
  • public List<string> DebugLog { get; }
  • public int ValidYears { get; set; }
  • public void ExportCertificateWithPrivateKey(string exportPath, SecureString password)
  • public void ImportCertificateWithPrivateKey(string importPath, SecureString password)

GSF.NumericalAnalysis

• public class AnalogFilter
• public class DigitalFilter
• public class FFT
• public class FilterState
• public static class NumericalAnalysisExtensions
  • public static double StandardDeviation(this IEnumerable<double> source, bool calculateForSample = false)
  • public static double StandardDeviation<T>(this IEnumerable<T> source, Func<T, double> selector, bool calculateForSample = false)
  • public static decimal StandardDeviation(this IEnumerable<decimal> source, bool calculateForSample = false)
  • public static decimal StandardDeviation<T>(this IEnumerable<T> source, Func<T, decimal> selector, bool calculateForSample = false)
  • public static float StandardDeviation(this IEnumerable<float> source, bool calculateForSample = false)
  • public static float StandardDeviation<T>(this IEnumerable<T> source, Func<T, float> selector, bool calculateForSample = false)
  • public static double StandardDeviation(this IEnumerable<double> source)
  • public static decimal StandardDeviation(this IEnumerable<decimal> source)
  • public static float StandardDeviation(this IEnumerable<float> source)
• public class Spline
• public class SplineFit

GSF.Parsing

• public static class StringParser
• public class TemplatedExpressionParser
  • public string Execute(IDictionary<string, string> substitutions, bool ignoreCase = true, bool evaluateExpressions = true, bool escapeSubstitutionValues = true)
  • public string Execute(IDictionary<string, string> substitutions, bool ignoreCase = true, bool evaluateExpressions = true)

GSF.Reflection

• public static class MemberInfoExtensions
  • public static bool AttributeExists<TMemberInfo, TAttribute>(this TMemberInfo member) where TMemberInfo : MemberInfo where TAttribute : Attribute

GSF.Scheduling

• public class Schedule
  • public DateTime NextTimeDue(DateTime targetDateTime)
  • public DateTime PreviousTimeDue(DateTime targetDateTime)
• public enum SchedulePartTextSyntax
  • RangeWithEveryN = 4

GSF.Security.Cryptography

• public static class Cipher
  • public static bool SystemAllowsManagedEncryption { get; }
  • public static Aes CreateAes()
  • public static SHA1 CreateSHA1()
  • public static SHA256 CreateSHA256()
  • public static SHA384 CreateSHA384()
  • public static SHA512 CreateSHA512()
• public class DataProtection

GSF.Security.Cryptography.X509

• public static class CertificateMaker
• public enum CertificateSigningMode
• public enum CipherEngine
• public class X509CertificateGenerator

GSF.Text

• public class Diff
• public class DiffMatchPatch
• public enum Operation
• public class Patch

GSF.Threading

• public static class ActionExtensions
  • public static bool TryExecute(this Action action, Action<Exception> exceptionHandler)
• public class DelayedSynchronizedOperation : SynchronizedOperationBase
• public class EventTimer : DisposableLoggingClassBase
• public static class LoadingAdjustedTimestamp
• public class LogicalThread
  • public LogicalThread(int priorityLevels)
• public static class LogicalThreadExtensions
• public class LogicalThreadScheduler
  • public int PriorityLevels { get; }
  • public LogicalThreadScheduler(int priorityLevels = 1)
  • public LogicalThreadScheduler()
  • public LogicalThread CreateThread(int priorityLevels)
• public sealed class ManagedCancellationTokenSource : IDisposable
• public sealed class SharedTimer : IDisposable
• public sealed class SharedTimerScheduler : IDisposable
• public static class ShutdownHandler
  • public static void InitiateSafeShutdown()
  • public static void InitiateSafeShutdown(string areYouSure)
• public class StaticTimer
  • public event EventHandler<EventArgs<Exception>> CallbackException
  • public StaticTimer()
  • protected void OnCallbackException(object sender, Exception ex)
  • public virtual ICancellationToken RegisterCallback(int interval, Action callback)
• public class TaskSynchronizedOperation : ISynchronizedOperation
• public static class WaitHandleExtensions
• public class WeakAction : WeakReference
  • public void Clear()
• public class WeakAction<T> : WeakReference
  • public void Clear()

GSF.Units

• public struct Angle : IComparable, IFormattable, IConvertible, IComparable<Angle>, IComparable<double>, IEquatable<Angle>, IEquatable<double>
  • public static Angle Average(IEnumerable<Angle> source)
  • public static Angle ConvertFrom(double value, AngleUnit sourceUnit)
  • public static IEnumerable<Angle> Unwrap(IEnumerable<Angle> source)
  • public double ConvertTo(AngleUnit targetUnit)
• public enum AngleUnit
• public struct Charge : IComparable, IFormattable, IConvertible, IComparable<Charge>, IComparable<double>, IEquatable<Charge>, IEquatable<double>
  • public static Charge ConvertFrom(double value, ChargeUnit sourceUnit)
  • public double ConvertTo(ChargeUnit targetUnit)
• public enum ChargeUnit
• public struct Current : IComparable, IFormattable, IConvertible, IComparable<Current>, IComparable<double>, IEquatable<Current>, IEquatable<double>
  • public static Current ConvertFrom(double value, CurrentUnit sourceUnit)
  • public double ConvertTo(CurrentUnit targetUnit)
• public enum CurrentUnit
• public struct Energy : IComparable, IFormattable, IConvertible, IComparable<Energy>, IComparable<double>, IEquatable<Energy>, IEquatable<double>
  • public static Energy ConvertFrom(double value, EnergyUnit sourceUnit)
  • public double ConvertTo(EnergyUnit targetUnit)
• public enum EnergyUnit
• public struct Length : IComparable, IFormattable, IConvertible, IComparable<Length>, IComparable<double>, IEquatable<Length>, IEquatable<double>
  • public static Length ConvertFrom(double value, LengthUnit sourceUnit)
  • public double ConvertTo(LengthUnit targetUnit)
• public enum LengthUnit
• public struct Mass : IComparable, IFormattable, IConvertible, IComparable<Mass>, IComparable<double>, IEquatable<Mass>, IEquatable<double>
  • public static Mass ConvertFrom(double value, MassUnit sourceUnit)
  • public double ConvertTo(MassUnit targetUnit)
• public enum MassUnit
• public struct Power : IComparable, IFormattable, IConvertible, IComparable<Power>, IComparable<double>, IEquatable<Power>, IEquatable<double>
  • public static Power ConvertFrom(double value, PowerUnit sourceUnit)
  • public double ConvertTo(PowerUnit targetUnit)
• public enum PowerUnit
• public struct Speed : IComparable, IFormattable, IConvertible, IComparable<Speed>, IComparable<double>, IEquatable<Speed>, IEquatable<double>
  • public static Speed ConvertFrom(double value, SpeedUnit sourceUnit)
  • public double ConvertTo(SpeedUnit targetUnit)
• public enum SpeedUnit
• public struct Temperature : IComparable, IFormattable, IConvertible, IComparable<Temperature>, IComparable<double>, IEquatable<Temperature>, IEquatable<double>
  • public static Temperature ConvertFrom(double value, TemperatureUnit sourceUnit)
  • public double ConvertTo(TemperatureUnit targetUnit)
• public enum TemperatureUnit
• public struct Time : IComparable, IFormattable, IConvertible, IComparable<Time>, IComparable<TimeSpan>, IComparable<double>, IEquatable<Time>, IEquatable<TimeSpan>, IEquatable<double>
  • public static Time ConvertFrom(double value, TimeUnit sourceUnit)
  • public static Time FromTicks(Ticks value)
  • public double ConvertTo(TimeUnit targetUnit)
• public enum TimeUnit
• public static class UnitExtensions
• public struct Voltage : IComparable, IFormattable, IConvertible, IComparable<Voltage>, IComparable<double>, IEquatable<Voltage>, IEquatable<double>
  • public static Voltage ConvertFrom(double value, VoltageUnit sourceUnit)
  • public double ConvertTo(VoltageUnit targetUnit)
• public enum VoltageUnit
• public struct Volume : IComparable, IFormattable, IConvertible, IComparable<Volume>, IComparable<double>, IEquatable<Volume>, IEquatable<double>
  • public static Volume ConvertFrom(double value, VolumeUnit sourceUnit)
  • public double ConvertTo(VolumeUnit targetUnit)
• public enum VolumeUnit

GSF.Units.EE

• public enum VoltageLevel
• public static class VoltageLevelExtensions

GSF.Xml

• public static class XmlExtensions
  • public static IEnumerable<XElement> Is(this IEnumerable<Tuple<XElement, string>> source, string attributeValue, bool ignoreCase = true)
  • public static IEnumerable<Tuple<XElement, string>> WhereAttribute(this IEnumerable<XElement> source, string attributeName)