GSF.Core by Grid Protection Alliance

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

---

API Diff between 2.3.135-beta and 2.1.437-beta

792 Additions 33 Removals

GSF

• 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 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 enum EnabledState
  • Auto = -1
  • Off = 0
  • On = 1
• public interface IMergeable<T>
  • T Merge(T other)
• public class NullableWeakReference : WeakReference
  • public NullableWeakReference(object target)
  • public virtual void Clear()
• public static class NumericExtensions
  • public static decimal Normalize(this decimal value)
• public class RadixCodec
  • public static RadixCodec Radix16
  • public static RadixCodec Radix2
  • public static RadixCodec Radix32
  • public static RadixCodec Radix36
  • public static RadixCodec Radix64
  • public static RadixCodec Radix8
  • public static RadixCodec Radix86
  • public readonly string Digits
  • public RadixCodec(string digits, bool caseSensitive)
  • public T Decode<T>(string radixValue)
  • public object Decode(Type type, string radixValue)
  • public string Encode(short value)
  • public string Encode(ushort value)
  • public string Encode(Int24 value)
  • public string Encode(UInt24 value)
  • public string Encode(int value)
  • public string Encode(uint value)
  • public string Encode(long value)
  • public string Encode(ulong value)
  • public bool TryDecode(string radixValue, out short value)
  • public bool TryDecode(string radixValue, out ushort value)
  • public bool TryDecode(string radixValue, out Int24 value)
  • public bool TryDecode(string radixValue, out UInt24 value)
  • public bool TryDecode(string radixValue, out int value)
  • public bool TryDecode(string radixValue, out uint value)
  • public bool TryDecode(string radixValue, out long value)
  • public bool TryDecode(string radixValue, out ulong value)
• 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 TRange End { get; }
  • public TRange Start { get; }
  • public TState State { get; }
  • public Range(TRange start, TRange end, TState state)
  • public static Range<TRange, TState> Merge(IEnumerable<Range<TRange, TState>> ranges)
  • public static Range<TRange, TState> Merge(IEnumerable<Range<TRange, TState>> ranges, Comparer<TRange> comparer)
  • public static Range<TRange, TState> Merge(IEnumerable<Range<TRange, TState>> ranges, Comparison<TRange> comparison)
  • public static IEnumerable<Range<TRange, TState>> MergeAllOverlapping(IEnumerable<Range<TRange, TState>> ranges)
  • public static IEnumerable<Range<TRange, TState>> MergeAllOverlapping(IEnumerable<Range<TRange, TState>> ranges, Comparison<TRange> comparison)
  • public static IEnumerable<Range<TRange, TState>> MergeAllOverlapping(IEnumerable<Range<TRange, TState>> ranges, IComparer<TRange> comparer)
  • public static IEnumerable<Range<TRange, TState>> MergeConsecutiveOverlapping(IEnumerable<Range<TRange, TState>> ranges)
  • public static IEnumerable<Range<TRange, TState>> MergeConsecutiveOverlapping(IEnumerable<Range<TRange, TState>> ranges, IComparer<TRange> comparer)
  • public static IEnumerable<Range<TRange, TState>> MergeConsecutiveOverlapping(IEnumerable<Range<TRange, TState>> ranges, Comparison<TRange> comparison)
  • public bool Contains(TRange value)
  • public bool Contains(TRange value, IComparer<TRange> comparer)
  • public bool Contains(TRange value, Comparison<TRange> comparison)
  • public bool Contains(Range<TRange, TState> range)
  • public bool Contains(Range<TRange, TState> range, IComparer<TRange> comparer)
  • public bool Contains(Range<TRange, TState> range, Comparison<TRange> comparison)
  • public Range<TRange, TState> Merge(Range<TRange, TState> range)
  • public Range<TRange, TState> Merge(Range<TRange, TState> range, IComparer<TRange> comparer)
  • public Range<TRange, TState> Merge(Range<TRange, TState> range, Comparison<TRange> comparison)
  • public bool Overlaps(Range<TRange, TState> range)
  • public bool Overlaps(Range<TRange, TState> range, IComparer<TRange> comparer)
  • public bool Overlaps(Range<TRange, TState> range, Comparison<TRange> comparison)
• public static class StringExtensions
  • public static T ConvertToType<T>(this string value, Type type)
  • public static T ConvertToType<T>(this string value, Type type, CultureInfo culture)
  • 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 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 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 double ToDays()
  • public double ToHours()
  • public double ToMinutes()

GSF.Collection

• public sealed class IndexedArray<T> : IEnumerable<T>, IEnumerable
• public class NullableArray<T> where T : struct
• public class SortedQueue<TKey, TValue>

GSF.Collections

• public static class CollectionExtensions
  • public static PagedList<T> ToPagedList<T>(this IEnumerable<T> source, int page, int pageSize)
  • public static PagedList<T> ToPagedList<T>(this IEnumerable<T> source, int page, int pageSize, int count = -1)
• public sealed 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 sealed 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 T this[int index] { get; set; }
  • public IndexedArray()
  • public IndexedArray(T defaultValue)
  • public void Clear()
• public class NullableArray<T> where T : struct
  • public NullableArray()
  • public void Add(int index, T item)
  • public void Clear()
  • public bool TryGet(int index, out T item)
• public class PagedList<T> : List<T>, IPagedList, IList, ICollection, IEnumerable
  • public PagedList(IEnumerable<T> source, int page, int pageSize)
  • public PagedList(IEnumerable<T> source, int page, int pageSize, int count = -1)
• public class SortedQueue<TKey, TValue>
  • public int Count { get; }
  • public TValue Head { get; }
  • public TValue this[TKey key] { get; set; }
  • public SortedQueue()
  • public KeyValuePair<TKey, TValue> Dequeue()
  • public void Enqueue(TKey key, TValue value)
  • public bool TryGetValue(TKey key, out TValue value)

GSF.ComponentModel

• public sealed class DefaultValueExpressionAttribute : ValueExpressionAttributeBase
  • public DefaultValueExpressionAttribute(string expression)
• public class EvaluationOrderException : Exception
  • public EvaluationOrderException(string message)
• public interface IValueExpressionAttribute
  • bool Cached { get; set; }
  • int EvaluationOrder { get; set; }
  • string Expression { get; }
  • TypeRegistry TypeRegistry { get; set; }
  • string GetExpressionUpdateValue(PropertyInfo property)
  • string GetPropertyUpdateValue(PropertyInfo property)
• public interface IValueExpressionScope<T>
  • T Instance { get; set; }
• public sealed class TypeConvertedValueExpressionAttribute : ValueExpressionAttributeBase
  • public Type ReturnType { get; }
  • public TypeConvertedValueExpressionAttribute(string expression, Type returnType = null)
• public static class TypeRegistryExtensions
  • public static TypeRegistry Clone(this TypeRegistry typeRegistry)
  • public static TypeRegistry RegisterSymbols(this IEnumerable<KeyValuePair<string, object>> symbols, TypeRegistry targetTypeRegistry = null)
• public sealed class UpdateValueExpressionAttribute : ValueExpressionAttributeBase
  • public UpdateValueExpressionAttribute(string expression)
• public abstract class ValueExpressionAttributeBase : Attribute, IValueExpressionAttribute
  • public bool Cached { get; set; }
  • public int EvaluationOrder { get; set; }
  • public string Expression { get; }
  • public TypeRegistry TypeRegistry { get; set; }
  • protected ValueExpressionAttributeBase(string expression)
  • public virtual string GetExpressionUpdateValue(PropertyInfo property)
  • public virtual string GetPropertyUpdateValue(PropertyInfo property)
• public class ValueExpressionParser : ValueExpressionParser<object>
  • public static TypeRegistry DefaultTypeRegistry { get; }
  • public ValueExpressionParser(string expression)
  • public ValueExpressionParser(IValueExpressionAttribute valueExpressionAttribute, PropertyInfo property)
  • public static string DeriveExpression(string expression, IValueExpressionAttribute valueExpressionAttribute, MemberInfo member, string typeName)
  • public static bool HasThisKeywords(string expression)
  • public static string ReplaceThisKeywords(string expression, string fieldName)
• public class ValueExpressionParser<T> : CompiledExpression<T>
  • public ValueExpressionParser(string expression)
  • public ValueExpressionParser(IValueExpressionAttribute valueExpressionAttribute, PropertyInfo property)
  • public static Action<T> ApplyDefaults(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null)
  • public static Action<TExpressionScope> ApplyDefaults<TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TExpressionScope : IValueExpressionScope<T>
  • public static Action<T> ApplyDefaultsForType<TValueExpressionAttribute>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute
  • public static Action<TExpressionScope> ApplyDefaultsForType<TValueExpressionAttribute, TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute where TExpressionScope : IValueExpressionScope<T>
  • public static Func<T> CreateInstance(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null)
  • public static Func<TExpressionScope, T> CreateInstance<TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TExpressionScope : IValueExpressionScope<T>
  • public static Func<T> CreateInstanceForType<TValueExpressionAttribute>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute
  • public static Func<TExpressionScope, T> CreateInstanceForType<TValueExpressionAttribute, TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute where TExpressionScope : IValueExpressionScope<T>
  • public static bool InitializeType()
  • public static Action<T> UpdateExpressions(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null)
  • public static Action<TExpressionScope> UpdateExpressions<TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TExpressionScope : IValueExpressionScope<T>
  • public static Action<T> UpdateExpressionsForType<TValueExpressionAttribute>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute
  • public static Action<TExpressionScope> UpdateExpressionsForType<TValueExpressionAttribute, TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute where TExpressionScope : IValueExpressionScope<T>
  • public static Action<T> UpdateInstance(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null)
  • public static Action<TExpressionScope> UpdateInstance<TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TExpressionScope : IValueExpressionScope<T>
  • public static Action<T> UpdateInstanceForType<TValueExpressionAttribute>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute
  • public static Action<TExpressionScope> UpdateInstanceForType<TValueExpressionAttribute, TExpressionScope>(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null) where TValueExpressionAttribute : Attribute, IValueExpressionAttribute where TExpressionScope : IValueExpressionScope<T>
  • public static Action<T> UpdateProperties(IEnumerable<PropertyInfo> properties = null, TypeRegistry typeRegistry = null)
  • public void Parse(Expression scope, TypeRegistry typeRegistry = null, bool isCall = false)
• public abstract class ValueExpressionScopeBase<T> : IValueExpressionScope<T>
  • public T Instance { get; set; }
  • protected ValueExpressionScopeBase()

GSF.ComponentModel.DataAnnotations

• public sealed class AcronymValidationAttribute : RegularExpressionAttribute
  • public const string DefaultErrorMessage = "Only upper case letters, numbers, '!', '-', '@', '#', '_' , '.' and '$' are allowed."
  • public const string ValidationPattern = "^[A-Z0-9\\-!_\\.@#\\$]+$"
  • public AcronymValidationAttribute()
• public sealed class EmailValidationAttribute : RegularExpressionAttribute
  • public const string DefaultErrorMessage = "Invalid e-mail address."
  • public const string ValidationPattern = "^\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$"
  • public EmailValidationAttribute()
• public sealed class InitialValueScriptAttribute : Attribute
  • public string InitialValueScript { get; }
  • public InitialValueScriptAttribute(string initialValueScript)
• public sealed class IsDeletedFlagAttribute : Attribute
  • public string FieldName { get; }
  • public IsDeletedFlagAttribute(string fieldName)
• 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 sealed class UrlValidationAttribute : RegularExpressionAttribute
  • public const string DefaultErrorMessage = "Invalid URL."
  • public const string ValidationPattern = "^(?:(?:[a-zA-Z][a-zA-Z0-9.+-]*:\\/\\/)?[a-zA-Z0-9][a-zA-Z0-9.-]*(?::[0-9]+)?(?:\\/[^ \"]*)?|mailto:[a-zA-Z0-9!#$%&'*+-\\/=?^_`{|}~][a-zA-Z0-9!#$%&'*+-\\/=?^_`{|}~.]*@[a-zA-Z0-9][a-zA-Z0-9.-]*)$"
  • public UrlValidationAttribute()

GSF.Configuration

• public abstract class CategorizedSettingsBase<TCategorizedSettings> : CategorizedSettingsBase<TypeConvertedValueExpressionAttribute, TCategorizedSettings> where TCategorizedSettings : CategorizedSettingsBase
  • protected CategorizedSettingsBase(string categoryName, TypeRegistry typeRegistry = null)
  • protected CategorizedSettingsBase(string categoryName, bool useCategoryAttributes, bool requireSerializeSettingAttribute, TypeRegistry typeRegistry = null)
  • protected CategorizedSettingsBase(ConfigurationFile configFile, string categoryName, bool useCategoryAttributes, bool requireSerializeSettingAttribute, bool initialize, TypeRegistry typeRegistry = null)
• public abstract class CategorizedSettingsBase<TValueExpressionAttribute, TCategorizedSettings> : CategorizedSettingsBase where TValueExpressionAttribute : Attribute, IValueExpressionAttribute where TCategorizedSettings : CategorizedSettingsBase
  • protected CategorizedSettingsBase(string categoryName, TypeRegistry typeRegistry = null)
  • protected CategorizedSettingsBase(string categoryName, bool useCategoryAttributes, bool requireSerializeSettingAttribute, TypeRegistry typeRegistry = null)
  • protected CategorizedSettingsBase(ConfigurationFile configFile, string categoryName, bool useCategoryAttributes, bool requireSerializeSettingAttribute, bool initialize, TypeRegistry typeRegistry = null)
  • public void UpdateExpressions()
  • public void UpdateProperties()
• 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 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
  • protected Schema m_fromSchema
  • protected long m_overallProgress
  • protected long m_overallTotal
  • protected Tables m_tableCollection
  • protected int m_timeout
  • protected Schema m_toSchema
  • protected bool m_useFromSchemaRI
  • public List<string> ExcludedTables { get; }
  • public virtual Schema FromSchema { get; set; }
  • public virtual int RowReportInterval { get; set; }
  • public virtual int Timeout { get; set; }
  • public virtual Schema ToSchema { get; set; }
  • public virtual bool UseFromSchemaReferentialIntegrity { get; set; }
  • public virtual Tables WorkTables { get; }
  • public event EventHandler<EventArgs<int, int>> OverallProgress
  • public event EventHandler<EventArgs<string, int, int>> RowProgress
  • public event EventHandler<EventArgs<string, Exception>> SQLFailure
  • public event EventHandler<EventArgs<string, bool, int, int>> TableProgress
  • protected BulkDataOperationBase()
  • protected BulkDataOperationBase(string fromConnectString, string toConnectString)
  • protected BulkDataOperationBase(Schema fromSchema, Schema toSchema)
  • public virtual void Analyze()
  • public virtual void Close()
  • protected virtual void Dispose(bool disposing)
  • public abstract void Execute()
  • protected virtual void OnOverallProgress(int Current, int Total)
  • protected virtual void OnRowProgress(string TableName, int CurrentRow, int TotalRows)
  • protected virtual void OnSQLFailure(string SQL, Exception ex)
  • protected virtual void OnTableProgress(string TableName, bool Executed, int CurrentTable, int TotalTables)
• public class DataDeleter : BulkDataOperationBase
  • public event EventHandler Disposed
  • public DataDeleter()
  • public DataDeleter(string fromConnectString, string toConnectString)
  • public DataDeleter(Schema fromSchema, Schema toSchema)
• public class DataInserter : BulkDataOperationBase
  • public bool AttemptBulkInsert { get; set; }
  • public bool AttemptTruncateTable { get; set; }
  • public Encoding BulkInsertEncoding { get; set; }
  • public string BulkInsertFilePath { get; set; }
  • public string BulkInsertSettings { get; set; }
  • public bool ClearDestinationTables { get; set; }
  • public string DelimiterReplacement { get; set; }
  • public bool ForceBulkInsert { get; set; }
  • public bool ForceTruncateTable { get; set; }
  • public bool PreserveAutoIncValues { get; set; }
  • public event EventHandler<EventArgs<string, int, int>> BulkInsertCompleted
  • public event EventHandler<EventArgs<string, string, Exception>> BulkInsertException
  • public event EventHandler<EventArgs<string>> BulkInsertExecuting
  • public event EventHandler Disposed
  • public event EventHandler<EventArgs<string>> TableCleared
  • public DataInserter()
  • public DataInserter(string FromConnectString, string ToConnectString)
  • public DataInserter(Schema FromSchema, Schema ToSchema)
• public class DataUpdater : BulkDataOperationBase
  • public event EventHandler Disposed
  • public DataUpdater()
  • public DataUpdater(string fromConnectString, string toConnectString)
  • public DataUpdater(Schema fromSchema, Schema toSchema)
• public class Field : IComparable
  • public bool AllowsNulls { get; }
  • public bool AutoIncrement { get; }
  • public int AutoIncrementSeed { get; }
  • public int AutoIncrementStep { get; }
  • public int DateTimePrecision { get; }
  • public object DefaultValue { get; }
  • public string Description { get; }
  • public ForeignKeyFields ForeignKeys { get; set; }
  • public bool HasDefault { get; }
  • public bool IsForeignKey { get; }
  • public bool IsPrimaryKey { get; set; }
  • public int MaxLength { get; }
  • public string Name { get; set; }
  • public string NonNullNativeValue { get; }
  • public int NumericPrecision { get; }
  • public int NumericScale { get; }
  • public int Ordinal { get; set; }
  • public Fields Parent { get; }
  • public string PrimaryKeyName { get; set; }
  • public int PrimaryKeyOrdinal { get; set; }
  • public bool ReadOnly { get; }
  • public Field ReferencedBy { get; }
  • public string SQLEncodedValue { get; }
  • public string SQLEscapedName { get; }
  • public Table Table { get; }
  • public OleDbType Type { get; set; }
  • public bool Unique { get; }
  • public object Value { get; set; }
  • public Field(string Name, OleDbType Type)
  • public int CompareTo(object obj)
• public class Fields : IEnumerable<Field>, IEnumerable
  • public int Count { get; }
  • public Field this[int index] { get; }
  • public Field this[string name] { get; }
  • public Table Parent { get; }
  • public void Add(Field newField)
  • public void Clear()
  • public IEnumerator<Field> GetEnumerator()
  • public string GetList(bool returnAutoInc = true, Func<string, string> sqlEscapeFunction = null)
  • public void Remove(Field field)
• public class ForeignKeyField
  • public ReferentialAction DeleteRule { get; set; }
  • public Field ForeignKey { get; set; }
  • public string KeyName { get; set; }
  • public int Ordinal { get; set; }
  • public ForeignKeyFields Parent { get; }
  • public Field PrimaryKey { get; set; }
  • public ReferentialAction UpdateRule { get; set; }
• public class ForeignKeyFields : IEnumerable
  • public int Count { get; }
  • public ForeignKeyField this[int index] { get; }
  • public ForeignKeyField this[string name] { get; }
  • public Field Parent { get; }
  • public IEnumerator GetEnumerator()
  • public string GetList()
• public interface IBulkDataOperation
  • Schema FromSchema { get; set; }
  • int RowReportInterval { get; set; }
  • int Timeout { get; set; }
  • Schema ToSchema { get; set; }
  • Tables WorkTables { get; }
  • event EventHandler<EventArgs<int, int>> OverallProgress
  • event EventHandler<EventArgs<string, int, int>> RowProgress
  • event EventHandler<EventArgs<string, Exception>> SQLFailure
  • event EventHandler<EventArgs<string, bool, int, int>> TableProgress
  • void Close()
  • void Execute()
• public enum ReferentialAction
  • Cascade = 0
  • NoAction = 3
  • SetDefault = 2
  • SetNull = 1
• public class Schema
  • public const TableType NoRestriction = 1023
  • public bool AllowNumericNulls { get; set; }
  • public bool AllowTextNulls { get; set; }
  • public IDbConnection Connection { get; set; }
  • public string ConnectionString { get; set; }
  • public DatabaseType DataSourceType { get; set; }
  • public bool ImmediateClose { get; set; }
  • public Tables Tables { get; set; }
  • public TableType TableTypeRestriction { get; set; }
  • public Schema()
  • public Schema(string connectionString, TableType tableTypeRestriction = 1023, bool immediateClose = true, bool analyzeNow = true)
  • public static IDbConnection OpenConnection(string connectionString)
  • public static IDbConnection OpenConnection(string connectionString, out DatabaseType databaseType, out Schema deserializedSchema, out bool isAdoConnection)
  • public void Analyze()
  • public void Close()
  • public string SQLEscapeName(string name)
• public class Table : IComparable, IComparable<Table>
  • public Field AutoIncField { get; }
  • public string Catalog { get; set; }
  • public IDbConnection Connection { get; }
  • public string Description { get; set; }
  • public Fields Fields { get; set; }
  • public string FullName { get; }
  • public bool HasAutoIncField { get; }
  • public string IdentitySQL { get; set; }
  • public bool IsForeignKeyTable { get; }
  • public bool IsLinked { get; }
  • public bool IsSystem { get; }
  • public bool IsTemporary { get; }
  • public bool IsView { get; }
  • public string MapName { get; set; }
  • public string Name { get; set; }
  • public Tables Parent { get; }
  • public int PrimaryKeyFieldCount { get; }
  • public int Priority { get; set; }
  • public bool Process { get; set; }
  • public bool ReferencedByForeignKeys { get; }
  • public int RowCount { get; }
  • public string Schema { get; set; }
  • public string SQLEscapedName { get; }
  • public TableType Type { get; set; }
  • public Table()
  • public Table(string name)
  • public Table(string catalog, string schema, string name, string type, string description, int rows)
  • public void CalculateRowCount()
  • public int CompareTo(object obj)
  • public int CompareTo(Table other)
  • public bool DefineForeignKey(string primaryKeyFieldName, string foreignKeyTableName, string foreignKeyFieldName, int foreignKeyOrdinal = -1, string foreignKeyName = "", ReferentialAction foreignKeyUpdateRule = 3, ReferentialAction foreignKeyDeleteRule = 3)
  • public bool DefinePrimaryKey(string fieldName, int primaryKeyOrdinal = -1, string primaryKeyName = "")
  • public bool IsReferencedBy(Table otherTable)
  • public bool IsReferencedVia(Table otherTable)
  • public void ReevalulateIdentitySQL()
  • public bool UsesDefaultSchema()
• public class Tables : IEnumerable<Table>, IEnumerable
  • public class ReferentialOrderComparer : IComparer<Table>
  • public int Count { get; }
  • public Table this[int index] { get; }
  • public Table this[string name] { get; }
  • public Schema Parent { get; }
  • public void Add(Table table)
  • public void Clear()
  • public Table FindByMapName(string mapName)
  • public IEnumerator<Table> GetEnumerator()
  • public string GetList()
  • public void Remove(Table table)
• public enum TableType
  • Alias = 16
  • GlobalTemp = 64
  • Link = 256
  • LocalTemp = 128
  • Synonym = 32
  • SystemTable = 4
  • SystemView = 8
  • Table = 1
  • Undetermined = 512
  • View = 2

GSF.Data.Model

• public enum AffixPosition
  • Prefix = 0
  • Suffix = 1
• public sealed class AmendExpressionAttribute : Attribute
  • public AffixPosition AffixPosition { get; set; }
  • public string AmendmentText { get; }
  • public StatementTypes StatementTypes { get; set; }
  • public DatabaseType? TargetDatabaseType { get; }
  • public TargetExpression TargetExpression { get; set; }
  • public AmendExpressionAttribute(string amendmentText)
  • public AmendExpressionAttribute(string amendmentText, DatabaseType targetDatabaseType)
• public sealed class EncryptDataAttribute : Attribute
  • public const string DefaultKeyReference = "DefaultTableOperationsKey"
  • public string KeyReference { get; }
  • public EncryptDataAttribute()
  • public EncryptDataAttribute(string keyReference)
• public sealed class FieldDataTypeAttribute : Attribute
  • public DbType FieldDataType { get; }
  • public DatabaseType? TargetDatabaseType { get; }
  • public FieldDataTypeAttribute(DbType fieldDataType)
  • public FieldDataTypeAttribute(DbType fieldDataType, DatabaseType targetDatabaseType)
• public sealed class InitialValueAttribute : Attribute
• public sealed class IsDeletedFlagAttribute : Attribute
• 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)
  • int DeleteRecord(RecordRestriction restriction, bool? applyRootQueryRestriction = default)
  • int DeleteRecordWhere(string filterExpression, object[] parameters)
  • 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)
  • int UpdateRecord(object record, RecordRestriction restriction = null)
  • bool TryGetFieldAttribute(string fieldName, Type attributeType, out Attribute attribute)
  • int UpdateRecord(object record, RecordRestriction restriction = null, bool? applyRootQueryRestriction = default)
  • int UpdateRecordWhere(object record, string filterExpression, object[] parameters)
  • int UpdateRecordWhere(DataRow row, string filterExpression, object[] parameters)
• public sealed class LabelAttribute : Attribute
• public sealed class NonRecordFieldAttribute : Attribute
  • public NonRecordFieldAttribute()
• public sealed class PrimaryLabelAttribute : Attribute
• public class RecordRestriction : IEquatable<RecordRestriction>
  • public RecordRestriction()
  • public object this[int index] { get; set; }
  • public static RecordRestriction Clone(RecordRestriction source)
  • 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 RootQueryRestrictionAttribute : Attribute
  • public bool ApplyToDeletes
  • public bool ApplyToUpdates
  • public readonly string FilterExpression
  • public readonly object[] Parameters
  • public RootQueryRestrictionAttribute(string filterExpression, object[] parameters)
• public enum StatementTypes
  • Delete = 32
  • Insert = 8
  • Select = 7
  • SelectCount = 1
  • SelectRow = 4
  • SelectSet = 2
  • Update = 16
• 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)
  • public TableOperations(AdoDataConnection connection, Action<Exception> exceptionHandler)
  • 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 Func<DataRow, T> LoadRecordFunction()
  • public static Func<T> NewRecordFunction()
  • public int AddNewOrUpdateRecord(T record)
  • public void ApplyRecordDefaults(T record)
  • public void ApplyRecordUpdates(T record)
  • public void ClearPrimaryKeyCache()
  • public int DeleteRecord(RecordRestriction restriction)
  • public int DeleteRecord(RecordRestriction restriction, bool? applyRootQueryRestriction = default)
  • public int DeleteRecordWhere(string filterExpression, object[] parameters)
  • 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)
  • public int UpdateRecord(T record, RecordRestriction restriction = null, bool? applyRootQueryRestriction = default)
  • public int UpdateRecordWhere(T record, string filterExpression, object[] parameters)
  • public int UpdateRecordWhere(DataRow row, string filterExpression, object[] parameters)
• public enum TargetExpression
  • FieldList = 1
  • TableName = 0

GSF.Diagnostics

• public sealed class ChildProcessManager : IDisposable
  • public event EventHandler<EventArgs<Exception>> TerminationException
  • public ChildProcessManager()
  • public void AddProcess(Process process)
  • public void Dispose()
• public class LogFileWriterInMemory
  • public int LogCount { get; }
  • public LogFileWriterInMemory()
  • public byte[] ToByteArray()
  • public void Write(LogMessage log)
• public sealed class ProcessUtilizationCalculator : IDisposable
  • public const int DefaultUpdateInterval = 5000
  • public Process AssociatedProcess { get; }
  • public int UpdateInterval { get; set; }
  • public double Utilization { get; }
  • public ProcessUtilizationCalculator()
  • public void Dispose()
  • public void Initialize(Process process)

GSF.IO

• 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 string[] GetDirectories(string path, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static string[] GetFileList(string path)
  • 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[] GetFiles(string path, string searchPattern = "*", SearchOption searchOption = 1, Action<Exception> exceptionHandler = null)
  • public static void ResetPermissions(string path)
• public sealed class FileProcessor : IDisposable
  • public IList<string> ActivelyEnumeratedPaths { get; }
  • public int EnumerationThreads { get; }
  • public bool IsCleaning { get; }
  • public bool IsEnumerating { get; }
  • public bool OrderedEnumeration { get; set; }
  • public bool MatchesFilter(string filePath)
  • public bool MatchesFilterMethod(string filePath)
• public class FileProcessorEventArgs : EventArgs
  • public bool RaisedByFileWatcher { get; }
  • public FileProcessorEventArgs(string fullPath, bool alreadyProcessed)
  • public int RetryCount { get; }
  • public FileProcessorEventArgs(string fullPath, bool alreadyProcessed, bool raisedByFileWatcher, Func<int> retryCounter)
• public class Outage : Range<DateTimeOffset>, IEquatable<Outage>
  • public bool Equals(Outage other)
• public class OutageLog : IProvideStatus, IDisposable
  • public virtual bool Enabled { get; set; }
  • public int Count { get; }
  • public List<Outage> Outages { get; }
  • public event EventHandler LogModified
  • public void Add(Outage outage)
  • public ManualResetEventSlim Flush()
  • public Outage First()
  • protected void InitiateRead()
  • protected void InitiateWrite()
  • protected virtual void OnProcessException(Exception ex)
  • public bool Remove(Outage outage)

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.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.NumericalAnalysis

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

GSF.Parsing

• public static class StringParser
  • public static bool ExpectedFieldNamesMatch(string[] expectedFieldNames, string[] actualFieldNames, bool matchCase = true, int length = 0)
  • public static int FindIndex(string fieldNameValueSought, string[] fieldNames, bool matchCase = true, bool contains = false)
  • public static string GetBetweenDelimiters(string inString, out int payloadIndex, char startToken = ',', char endToken = ',', int startIndex = 0, bool matchCase = true, bool includeTokensInReturn = false)
  • public static int IndexOfMatchingCloseToken(string inString, string openToken, string closeToken, int startIndex = 0, bool matchCase = true)
  • public static int IndexOfMatchingCloseToken(string inString, char openToken, char closeToken, int startIndex = 0, bool matchCase = true)
  • public static int IndexOfNextToken(string inString, char token, int startIndex = 0, int occurrenceCount = 1, bool matchCase = true)
  • public static int IndexOfNextToken(string inString, string token, int startIndex = 0, int occurrenceCount = 1, bool matchCase = true)
  • public static int IndexOfNextTokens(string inString, char[] tokens, int startIndex = 0, bool matchCase = true)
  • public static int IndexOfPreviousToken(string inString, char token, int startIndex = 0, int occurrenceCount = 1, bool matchCase = true)
  • public static int IndexOfPreviousToken(string inString, string token, int startIndex = 0, int occurrenceCount = 1, bool matchCase = true)
  • public static int[] IndicesOfToken(string inString, char token, int startIndex = 0, bool matchCase = true)
  • public static int[] IndicesOfToken(string inString, string token, int startIndex = 0, bool matchCase = true)
  • public static int[] IndicesOfTokens(string inString, char[] tokens, int startIndex = 0, bool matchCase = true)
  • public static bool ParseCheck(string[] parsedStrings, TypeCode[] expectedTypeCodes, out object values)
  • public static string[] ParseLine(string inString, char[] quoteChars, char[] delimiters, int startIndex = 0, bool removeResultQuotes = true)
  • public static string[] ParseStandardCSV(string inString, int startIndex = 0, bool removeResultQuotes = 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 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()

GSF.Security.Cryptography.X509

• public static class CertificateMaker
  • public static X509Certificate2 GenerateSelfSignedCertificate(CertificateSigningMode mode, string subjectName, DateTime startDate = default, DateTime endDate = default)
• public enum CertificateSigningMode
  • ECDSA_256_SHA2_256 = 8
  • ECDSA_384_SHA2_384 = 9
  • ECDSA_521_SHA2_512 = 10
  • RSA_1024_SHA_1 = 0
  • RSA_15360_SHA2_512 = 7
  • RSA_2048_SHA2_256 = 1
  • RSA_3072_SHA2_256 = 2
  • RSA_3072_SHA2_384 = 3
  • RSA_4096_SHA2_256 = 4
  • RSA_4096_SHA2_384 = 5
  • RSA_7680_SHA2_384 = 6
• public enum CipherEngine
  • ECDsaCng = 2
  • RSACng = 1
  • RSACryptoServiceProvider = 0
• public class X509CertificateGenerator
  • public CipherEngine CipherEngine
  • public string Issuer
  • public int KeySize
  • public DateTime NotAfter
  • public DateTime NotBefore
  • public long SerialNumber
  • public int SignatureBits
  • public string Subject
  • public X509CertificateGenerator()
  • public X509Certificate2 Generate()
  • public void GenerateFile(string fileName, string password)

GSF.Threading

• public class DelayedSynchronizedOperation : SynchronizedOperationBase
  • public const int DefaultDelay = 1000
  • public int Delay { get; set; }
  • public DelayedSynchronizedOperation(Action action)
  • public DelayedSynchronizedOperation(Action action, Action<Exception> exceptionAction)
• public class LogicalThread
  • public LogicalThread(int priorityLevels)
• public class LogicalThreadScheduler
  • public int PriorityLevels { get; }
  • public LogicalThreadScheduler()
  • public LogicalThreadScheduler(int priorityLevels = 1)
  • public LogicalThread CreateThread(int priorityLevels)
• public class WeakAction : NullableWeakReference
  • public void Clear()
• public class WeakAction<T> : NullableWeakReference
  • public void Clear()

GSF.Units

• public struct Angle : IComparable, IFormattable, IConvertible, IComparable<Angle>, IComparable<double>, IEquatable<Angle>, IEquatable<double>
  • public static Angle ConvertFrom(double value, AngleUnit sourceUnit)
  • public double ConvertTo(AngleUnit targetUnit)
• public enum AngleUnit
  • AngularMil = 5
  • ArcMinutes = 3
  • ArcSeconds = 4
  • Degrees = 1
  • Grads = 2
  • Radians = 0
• 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
  • Abcoulombs = 2
  • AmpereHours = 1
  • AtomicUnitsOfCharge = 4
  • Coulombs = 0
  • Faraday = 5
  • Statcoulombs = 3
• 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
  • Abamperes = 1
  • Amperes = 0
  • Statamperes = 2
• 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
  • BarrelsOfOil = 7
  • BTU = 2
  • Calories = 5
  • CelsiusHeatUnits = 3
  • HorsepowerHours = 6
  • Joules = 0
  • LitersAtmosphere = 4
  • TonsOfCoal = 8
  • WattHours = 1
• 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
  • Feet = 1
  • Inches = 2
  • LightSeconds = 4
  • Meters = 0
  • Miles = 3
  • NauticalMiles = 7
  • USSurveyFeet = 5
  • USSurveyMiles = 6
  • Yards = 8
• 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
  • Kilograms = 0
  • LongTons = 6
  • MectricTons = 5
  • MetricPounds = 3
  • Ounces = 1
  • Pounds = 2
  • Tons = 4
• 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
  • BoilerHorsepower = 3
  • BTUPerSecond = 4
  • CaloriesPerSecond = 5
  • Horsepower = 1
  • LitersAtmospherePerSecond = 6
  • MetricHorsepower = 2
  • Watts = 0
• 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
  • FeetPerMinute = 3
  • InchesPerSecond = 4
  • KilometersPerHour = 2
  • Knots = 5
  • Mach = 6
  • MetersPerSecond = 0
  • MilesPerHour = 1
• 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
  • Celsius = 1
  • Delisle = 5
  • Fahrenheit = 2
  • Kelvin = 0
  • Newton = 3
  • Rankine = 4
  • Réaumur = 6
  • Rømer = 7
• 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
  • AtomicUnitsOfTime = 6
  • Days = 3
  • Hours = 2
  • Ke = 8
  • Minutes = 1
  • PlanckTime = 7
  • Seconds = 0
  • Ticks = 5
  • Weeks = 4
• 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
  • Abvolts = 1
  • Statvolts = 2
  • Volts = 0
• 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
  • CubicFeet = 13
  • CubicInches = 12
  • CubicMeters = 0
  • Cups = 6
  • FluidOunces = 8
  • Gallons = 11
  • Liters = 1
  • MetricCups = 7
  • MetricTablespoons = 5
  • MetricTeaspoons = 3
  • Pints = 9
  • Quarts = 10
  • Tablespoons = 4
  • Teaspoons = 2