GSF.Core by Grid Protection Alliance

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

---

API Diff between 2.0.233-beta and 2.3.320-beta

53 Additions 511 Removals

GSF

• 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 PlatformID GetOSPlatformID()
  • 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 struct ComplexNumber : IEquatable<ComplexNumber>
  • public static Complex op_Implicit(ComplexNumber value)
  • public static ComplexNumber op_Implicit(Complex value)
  • public static ComplexNumber Parse(string str)
• public class DateTimeRounding
• public static class EmptyArray<T>
• public enum EnabledState
• public static class Encoding7Bit
• public static class EnumExtensions
  • public static T GetEnumValueOrDefault<T>(this object value, object defaultValue = null)
  • public static object GetEnumValueOrDefault(this object value, Type type, object defaultValue = null)
• public interface IMergeable<T>
• public interface ISupportLifecycle : IDisposable
  • bool IsDisposed { get; }
• public interface ITrackable : IChangeTracking
• public class NtpTimeTag : TimeTagBase
  • public NtpTimeTag(decimal seconds)
  • public NtpTimeTag(double seconds)
  • public static long GetBaseDateOffsetTicks(decimal seconds)
  • public static long GetBaseDateOffsetTicks(double seconds)
• public class NullableWeakReference : WeakReference
• public static class NumericExtensions
  • public static decimal Normalize(this decimal value)
• public static class OptimizationOptions
• public class RadixCodec
• public class Range<T>
• public sealed class Range<TRange, TState>
• public struct ShortTime : IEquatable<ShortTime>
• 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 bool IsNullOrWhiteSpace(this string value)
  • public static bool IsPlural(this string value)
  • public static bool IsSingular(this string value)
  • 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 static string ToCamelCase(this string value)
  • public static string ToPascalCase(this string value)
  • public static string ToPlural(this string value)
  • public static string ToSingular(this string value)
  • public static Stream ToStream(this string value, Encoding encoding = null)
  • public static Task<Stream> ToStreamAsync(this string value, Encoding encoding = null)
  • public static string ToTitleCase(this string value, CultureInfo culture = null)
  • public static string ToTitleCase(this string value)
• 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 RoundToSubsecondDistribution(Ticks timestamp, int samplesPerSecond)
  • 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 virtual decimal Value { get; }
  • protected TimeTagBase(long baseDateOffsetTicks, decimal seconds)
  • public virtual double Value { get; set; }
  • protected TimeTagBase(long baseDateOffsetTicks, double seconds)
• public class Trackable<T> : ITrackable, IChangeTracking
• public class TransformEqualityComparer<T> : IEqualityComparer<T>
• public static class TypeExtensions
  • public static string GetFriendlyClassName(this Type type)
• public class UnixTimeTag : TimeTagBase
  • public UnixTimeTag(decimal seconds)
  • public UnixTimeTag(double seconds)

GSF.Adapters

• public class Adapter : MarshalByRefObject, IAdapter, ISupportLifecycle, IDisposable, IProvideStatus, IPersistSettings
  • public bool IsDisposed { get; }
• public class AdapterLoader<T> : ISupportLifecycle, IDisposable, IProvideStatus, IPersistSettings where T : IAdapter
  • protected SafeFileWatcher AdapterWatcher { get; }
  • protected FileSystemWatcher AdapterWatcher { get; }
  • public bool IsDisposed { get; }

GSF.Collections

• public class AsyncQueue<T>
  • public AsyncQueue(SynchronizedOperationType synchronizedOperationType)
• 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 TValue GetOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
  • public static TValue GetOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> defaultValueFactory)
  • 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 Dictionary<string, string> ToDictionary(this NameValueCollection collection)
  • public static PagedList<T> ToPagedList<T>(this IEnumerable<T> source, int page, int pageSize, int count = -1)
• 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
  • public long CacheSize { get; set; }
  • public byte[] DefaultSignature { get; }
  • public int FragmentationCount { get; }
  • public byte[] Signature { get; set; }
  • protected virtual void Dispose(bool disposing)
  • public void OpenRead()
• public sealed class FileBackedHashSet<T> : ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IDisposable
• public sealed class IndexedArray<T> : IEnumerable<T>, IEnumerable
• public interface IPagedList : IList, ICollection, IEnumerable
• public class IsolatedQueue<T>
  • public int Count { get; }
  • public long Count { get; }
  • public void Enqueue(T item)
  • public void Enqueue(T item)
• public static class ListExtensions
• public class NullableArray<T> where T : struct
• public class PagedList<T> : List<T>, IPagedList, IList, ICollection, IEnumerable
• public class ProcessQueue<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IProvideStatus, ISupportLifecycle, IDisposable
  • public ICancellationToken CancellationToken { get; }
  • public bool IsDisposed { get; }
• public class RollingWindow<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
• 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
  • public static string ToConnectionString(XElement element)
  • public static XElement ToXML(string connectionString)
• 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)+"
  • public static string Escape(string arg)
  • public static string[] ToArgs(string command)

GSF.Data

• public class AdoDataConnection : IDisposable
  • public int DefaultTimeout { get; set; }
  • public bool IsPostgreSQL { get; }
  • public AdoDataConnection(string connectionString, Type connectionType, Type adapterType)
  • public AdoDataConnection(IDbConnection connection, Type adapterType, bool disposeConnection)
  • public static string ToDataProviderString(Type connectionType, Type adapterType)
  • public string EscapeIdentifier(string identifier, bool useAnsiQuotes = false)
  • public IDataReader ExecuteReader(CommandBehavior behavior, int timeout, string sqlFormat, object[] parameters)
  • 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 void ExecuteScript(string scriptPath)
  • public void ExecuteScript(TextReader scriptReader)
• public abstract class BulkDataOperationBase : IBulkDataOperation, IDisposable
• public enum DatabaseType
  • PostgreSQL = 5
• public class DataDeleter : BulkDataOperationBase
• public static class DataExtensions
  • public static T ConvertField<T>(this DataRow row, string field, T defaultValue)
  • public static object ConvertField(this DataRow row, string field, Type type)
  • public static object ConvertField(this DataRow row, string field, Type type, object defaultValue)
  • public static Guid ConvertGuidField(this DataRow row, string field, Guid? defaultValue = default)
  • public static void ExecuteMySQLScript(this IDbConnection connection, string scriptPath)
  • public static void ExecuteMySQLScript(this IDbConnection connection, TextReader scriptReader)
  • public static void ExecuteOracleScript(this IDbConnection connection, string scriptPath)
  • public static void ExecuteOracleScript(this IDbConnection connection, TextReader scriptReader)
  • public static void ExecuteTSQLScript(this IDbConnection connection, string scriptPath)
  • public static void ExecuteTSQLScript(this IDbConnection connection, TextReader scriptReader)
• public class DataInserter : BulkDataOperationBase
• public static class DataRowExtensions
• public static class DataSetExtensions
  • public static void SerializeToStream(this DataSet source, Stream destination, bool assumeStringForUnknownTypes = true, bool useNullableDataTypes = true)
  • public static void SerializeToStream(this DataSet source, Stream destination, bool assumeStringForUnknownTypes = true)
• 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 enum AffixPosition
• public sealed class AmendExpressionAttribute : Attribute
• public sealed class CSVExcludeFieldAttribute : Attribute
• public sealed class EncryptDataAttribute : Attribute
• public sealed class FieldDataTypeAttribute : Attribute
• public sealed class FieldNameAttribute : Attribute
• public interface ITableOperations
• public sealed class NonRecordFieldAttribute : Attribute
• public sealed class PrimaryKeyAttribute : Attribute
• public enum RecordOperation
• public sealed class RecordOperationAttribute : Attribute
• public class RecordRestriction : IEquatable<RecordRestriction>
• public sealed class RootQueryRestrictionAttribute : Attribute
• public sealed class SearchableAttribute : Attribute
• public enum SearchType
• public enum StatementTypes
• public sealed class TableNameAttribute : Attribute
• public class TableOperations<T> : ITableOperations
• public enum TargetExpression
• public sealed class UseEscapedNameAttribute : Attribute

GSF.Diagnostics

• public sealed class ChildProcessManager : IDisposable
• public abstract class DisposableLoggingClassBase : IDisposable
• public sealed class LogEventPublisher
• public sealed class LogEventPublisherDetails : IEquatable<LogEventPublisherDetails>
• public static class LogFileCompactor
• public static class LogFileReader
• public sealed class LogFileWriter : IDisposable
• public class LogFileWriterInMemory
• public static class Logger
• public sealed class LogMessage
• public class LogPublisher
• public class LogStackFrame : IEquatable<LogStackFrame>
• public class LogStackMessages : IEquatable<LogStackMessages>
• public class LogStackTrace : IEquatable<LogStackTrace>
• public sealed class LogSubscriber : IDisposable
• public class LogSubscriptionConsole
• public sealed class LogSubscriptionFileWriter : IDisposable
• public enum MessageClass
• public enum MessageFlags
• public enum MessageLevel
• public enum MessageLevelFlags
• public struct MessageRate
• public enum MessageSuppression
• public sealed delegate NewLogMessageEventHandler : MulticastDelegate
• public sealed class ProcessUtilizationCalculator : IDisposable
• public sealed class PublisherTypeDefinition : IEquatable<PublisherTypeDefinition>
• public static class ThreadPoolMonitor
• public static class ThreadPoolTrace
• public static class TimerTrace
• public enum VerboseLevel

GSF.Drawing

• public static class BitmapExtensions
  • public static Bitmap FromPixelData(int width, uint[] pixelData)
  • public static uint[] ToPixelData(this Bitmap bitmap)
• public class Point

GSF.ErrorManagement

• public class ErrorLogger : Component, ISupportLifecycle, IDisposable, ISupportInitialize, IProvideStatus, IPersistSettings
  • public bool IsDisposed { get; }

GSF.IO

• public class BlockAllocatedMemoryStream : Stream
  • public const int DefaultBlockSize = 65536
  • 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 class CachedFileStream : Stream
• public enum FileEnumerationStrategy
• 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<string> EnumerateFiles(string path, 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 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 string GetValidFilePath(string filePath, char replaceWithCharacter = '_')
  • public static void ResetPermissions(string path)
  • public static void ValidatePathName(string filePath)
• public sealed class FileProcessor : IDisposable
  • public const FileEnumerationStrategy DefaultEnumerationStrategy = 2
  • public const string DefaultFolderExclusion = ""
  • public const int DefaultInternalBufferSize = 8192
  • public const int DefaultMaxFragmentation = 10
  • public IList<string> ActivelyEnumeratedPaths { get; }
  • public const bool DefaultUseTimer = false
  • public FileEnumerationStrategy EnumerationStrategy { get; set; }
  • public Func<string, bool> FilterMethod { get; set; }
  • public string FolderExclusion { get; set; }
  • public int InternalBufferSize { get; set; }
  • public bool IsCleaning { get; }
  • public bool IsEnumerating { get; }
  • public TimeSpan LastCompactDuration { get; }
  • public DateTime LastCompactTime { get; }
  • public int MaxFragmentation { get; set; }
  • public int MaxThreadCount { get; set; }
  • public bool OrderedEnumeration { get; set; }
  • public int ProcessedFileCount { get; }
  • public int RequeuedFileCount { get; }
  • public int SkippedFileCount { get; }
  • public bool UseTimer { get; set; }
  • public void EnumerateWatchDirectories()
  • public bool MatchesFilter(string filePath)
  • public bool MatchesFilterMethod(string filePath)
  • public bool MatchesFolderExclusion(string folderPath)
  • public void StopEnumeration()
• public class FileProcessorEventArgs : EventArgs
  • public bool RaisedByFileWatcher { get; }
  • public int RetryCount { get; }
  • public FileProcessorEventArgs(string fullPath, bool alreadyProcessed, bool raisedByFileWatcher, Func<int> retryCounter)
  • public FileProcessorEventArgs(string fullPath, bool alreadyProcessed)
• public abstract class IsamDataFileBase<T> : ISupportLifecycle, IDisposable, IProvideStatus, IPersistSettings where T : ISupportBinaryImage
  • public bool IsDisposed { get; }
• public class LogFile : Component, ISupportLifecycle, IDisposable, ISupportInitialize, IProvideStatus, IPersistSettings
  • public bool IsDisposed { get; }
• public class MultipleDestinationExporter : Component, ISupportLifecycle, IDisposable, ISupportInitialize, IProvideStatus, IPersistSettings
  • public bool IsDisposed { get; }
• public class Outage
  • public Outage(Range<DateTimeOffset> range)
  • public Outage(DateTimeOffset startTime, DateTimeOffset endTime)
  • public static IEnumerable<Outage> MergeOverlapping(IEnumerable<Outage> outages)
  • public bool Equals(Outage other)
  • public DateTime EndTime { get; set; }
  • public DateTime StartTime { get; set; }
  • public Outage()
  • public Outage(DateTime startTime, DateTime endTime)
• public class OutageLog : ObservableCollection<Outage>, ISupportLifecycle, IDisposable, IProvideStatus
  • public int Count { get; }
  • public virtual bool Enabled { get; set; }
  • public bool IsDisposed { get; }
  • public List<Outage> Outages { get; }
  • public event EventHandler LogModified
  • public void Add(DateTimeOffset startTime, DateTimeOffset endTime)
  • public void Add(Outage outage)
  • public void Add(Ticks startTime, Ticks endTime)
  • 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 bool IsDisposed { get; }
  • public DateTimeOffset RunningTime { get; set; }
  • public DateTimeOffset StartTime { get; set; }
  • public DateTime RunningTime { get; set; }
  • public DateTime StartTime { get; set; }
  • public DateTimeOffset StopTime { get; set; }
  • public TimeSpan UpTime { get; }
  • public DateTime StopTime { get; set; }
• public class SafeFileWatcher : IDisposable
• public static class StreamExtensions
  • public static void CopyTo(this Stream source, Stream destination, long length, byte[] buffer)
  • public static uint Read7BitUInt32(this Stream stream)
  • public static void ReadAll(this Stream stream, byte[] buffer, int position, int length)
  • public static bool ReadBoolean(this Stream stream)
  • public static byte[] ReadBytes(this Stream stream)
  • public static byte[] ReadBytes(this Stream stream, int length)
  • public static char ReadChar(this Stream stream)
  • public static DateTime ReadDateTime(this Stream stream)
  • public static decimal ReadDecimal(this Stream stream)
  • public static double ReadDouble(this Stream stream)
  • public static Guid ReadGuid(this Stream stream)
  • public static short ReadInt16(this Stream stream)
  • public static int ReadInt32(this Stream stream)
  • public static int[] ReadInt32Collection(this Stream stream)
  • public static long ReadInt64(this Stream stream)
  • public static byte ReadNextByte(this Stream stream)
  • public static string ReadNullableString(this Stream stream)
  • public static object ReadObject(this Stream stream)
  • public static sbyte ReadSByte(this Stream stream)
  • public static float ReadSingle(this Stream stream)
  • public static string ReadString(this Stream stream)
  • public static string[] ReadStringCollection(this Stream stream)
  • public static ushort ReadUInt16(this Stream stream)
  • public static uint ReadUInt32(this Stream stream)
  • public static ulong ReadUInt64(this Stream stream)
  • public static void Write(this Stream stream, byte value)
  • public static void Write(this Stream stream, bool value)
  • public static void Write(this Stream stream, sbyte value)
  • public static void Write(this Stream stream, short value)
  • public static void Write(this Stream stream, ushort value)
  • public static void Write(this Stream stream, char value)
  • public static void Write(this Stream stream, int value)
  • public static void Write(this Stream stream, uint value)
  • public static void Write(this Stream stream, float value)
  • public static void Write(this Stream stream, long value)
  • public static void Write(this Stream stream, ulong value)
  • public static void Write(this Stream stream, double value)
  • public static void Write(this Stream stream, DateTime value)
  • public static void Write(this Stream stream, decimal value)
  • public static void Write(this Stream stream, Guid value)
  • public static void Write(this Stream stream, byte[] value)
  • public static void Write(this Stream stream, string value)
  • public static void WriteCollection(this Stream stream, ICollection<string> collection)
  • public static void WriteCollection(this Stream stream, ICollection<int> collection)
  • public static void WriteNullable(this Stream stream, string value)
  • public static void WriteObject(this Stream stream, object value)
  • public static void WriteWithLength(this Stream stream, byte[] value)

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 IPrincipal PassthroughPrincipal { get; set; }

GSF.Immutable

• public interface IImmutableObject : ICloneable
• public interface IImmutableObject<T> : IImmutableObject, ICloneable
• public sealed class ImmutableArray<T> : ImmutableObjectBase<ImmutableArray<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
• public sealed class ImmutableDictionary<TKey, TValue> : ImmutableObjectBase<ImmutableDictionary<TKey, TValue>>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
• public class ImmutableList<T> : ImmutableObjectBase<ImmutableList<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
• public abstract class ImmutableObjectAutoBase<T> : ImmutableObjectBase<T> where T : ImmutableObjectAutoBase<T>
• public abstract class ImmutableObjectBase<T> : IImmutableObject<T>, IImmutableObject, ICloneable where T : ImmutableObjectBase<T>

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 void ExportCertificateWithPrivateKey(string exportPath, SecureString password)
  • public void ImportCertificateWithPrivateKey(string importPath, SecureString password)

GSF.Net.Smtp

• public class Mail : IDisposable
  • public bool EnableSSL { get; set; }
  • public string Password { get; set; }
  • public SecureString SecurePassword { get; set; }
  • public string Username { get; set; }
  • public Mail()
  • public Mail(string from)
  • public static void Send(string from, string toRecipients, string subject, string body, bool isBodyHtml, string smtpServer, string username, string password)
  • public static void Send(string from, string toRecipients, string subject, string body, bool isBodyHtml, string smtpServer, string username, SecureString password)
  • public static void Send(string from, string toRecipients, string subject, string body, bool isBodyHtml, string smtpServer, string username, string password, bool enableSSL)
  • public static void Send(string from, string toRecipients, string subject, string body, bool isBodyHtml, string smtpServer, string username, SecureString password, bool enableSSL)

GSF.NumericalAnalysis

• public static class Euclidean
  • public static double Mod(double numerator, double denominator)
  • public static double Wrap(double value, double minimum, double range)
• 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)

GSF.NumericalAnalysis.Interpolation

• public sealed delegate DistanceFunc : MulticastDelegate
• public sealed delegate IDWFunc : MulticastDelegate
• public class InverseDistanceWeightingFunction
• public class PiecewiseLinearFunction

GSF.Parsing

• public class BooleanExpression
• public abstract class FrameImageParserBase<TTypeIdentifier, TOutputType> : BinaryImageParserBase, IFrameImageParser<TTypeIdentifier, TOutputType>, IBinaryImageParser, IProvideStatus where TOutputType : ISupportFrameImage<TTypeIdentifier>
  • public virtual bool AllowObjectPooling { get; }
• 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 class AppDomainTypeLookup
• public static class AssemblyExtensions
  • public static bool Debuggable(this Assembly assemblyInstance)
• public class AssemblyInfo
  • public bool Debuggable { get; }
  • public static Type FindType(string typeName)
• public static class AssemblyLoadedVersionNumber
• public static class MemberInfoExtensions
  • public static bool AttributeExists<TMemberInfo, TAttribute>(this TMemberInfo member) where TMemberInfo : MemberInfo where TAttribute : Attribute
  • public static string GetFriendlyClassName<TMemberInfo>(this TMemberInfo member) where TMemberInfo : MemberInfo
  • public static bool TryGetAttribute<TMemberInfo>(this TMemberInfo member, string attributeName, out Attribute attribute) where TMemberInfo : MemberInfo
  • public static bool TryGetAttributes<TMemberInfo>(this TMemberInfo member, string attributeName, out Attribute attributes) where TMemberInfo : MemberInfo
• public static class MethodBaseExtensions
• public static class MethodInfoExtensions

GSF.Scheduling

• public class Schedule
  • public bool UseLocalTime { get; set; }
  • public Schedule(string name, string rule, string description, bool useLocalTime)
• public class ScheduleManager : Component, ISupportLifecycle, IDisposable, ISupportInitialize, IProvideStatus, IPersistSettings
  • public bool IsDisposed { get; }
• public enum SchedulePartTextSyntax
  • RangeWithEveryN = 4

GSF.Security.Cryptography

• public class CharacterGroup
• 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 PasswordGenerator

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 class CancellationToken : ICancellationToken
• public class CompatibleCancellationToken : ICancellationToken
• public class DedicatedSynchronizedOperation : SynchronizedOperationBase
• public class DelayedSynchronizedOperation : SynchronizedOperationBase
• public struct DisposableCallback : IDisposable
• public class EventTimer : DisposableLoggingClassBase
• public interface ICancellationToken
• public static class InterprocessLock
  • public static Mutex GetNamedMutex(bool perUser = true)
  • public static Semaphore GetNamedSemaphore(bool perUser = true, int maximumCount = 10, int initialCount = -1)
• public static class LoadingAdjustedTimestamp
• public class LogicalThread
• public sealed class LogicalThreadLocal<T> : IDisposable
• public class LogicalThreadOperation
• public class LogicalThreadScheduler
• public class LogicalThreadStatistics
• public class RateLimiter
• public class ScheduledTask : IDisposable
  • public ScheduledTask(ThreadingMode threadMode = 2, ThreadPriority priority = 2, bool disposeOnShutdown = false)
  • public ScheduledTask(ThreadingMode threadMode = 2, ThreadPriority priority = 2)
• public sealed class SharedTimer : IDisposable
• public sealed class SharedTimerScheduler : IDisposable
• public static class ShutdownHandler
• public enum ShutdownHandlerOrder
• public class SingleOccurrenceAction
• public class StateMachine
• public enum SynchronizedOperationType
  • DedicatedBackground = 5
  • DedicatedForeground = 4
• public static class WaitHandleExtensions
• public class WeakAction : WeakReference
  • public WeakAction(Action callback)
  • public WeakAction(Action callback, out object localStrongReference)
  • public void Clear()
• public class WeakAction<T> : WeakReference
  • public WeakAction(Action<T> callback)
  • public WeakAction(Action<T> callback, out object localStrongReference)
  • 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 struct Phasor : IEquatable<Phasor>
  • public ComplexNumber Conjugate { get; }
  • public static Power CalculateActivePower(Phasor voltage, Phasor current)
  • public static Power CalculateApparentPower(Phasor voltage, Phasor current)
  • public static ComplexNumber CalculateComplexPower(Phasor voltage, Phasor current)
  • public static Power CalculateReactivePower(Phasor voltage, Phasor current)
  • public static Angle CalculateRelativePhase(Phasor voltage, Phasor current)
  • public static Complex op_Implicit(Phasor phasor)

GSF.Xml

• public static class XmlExtensions
  • public static string ApplyXSLTransform(this string document, string transform)
  • public static object Format(this XElement element)
  • public static void TransformAll(this XDocument document, XName name, Func<XElement, object> selector)
  • public static void TransformAll(this XDocument document, XName name, Func<XElement, int, object> selector)