C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Expressions;

public class Program
{
	public static void Main()
	{
		Console.WriteLine("Hello World");
		
	}
	
	    public void Evaluate(string expression, Dictionary<string, object> parameters)
        {
			CustomExpressions Lib = new CustomExpressions();
			
            //to make this backwards compatible with ncalc, we must remove [] params
            expression = expression.Replace("[", string.Empty);
            expression = expression.Replace("]", string.Empty);

            var e = new DynamicExpression(expression, ExpressionLanguage.Csharp);
            var context = new ExpressionContext { Owner = Lib };
            context.Imports.Add(new Import(typeof(Math)));

            foreach (var parameter in parameters)
            {
                context.Variables.Add(parameter.Key, parameter.Value);
            }

            try
            {
                e.Invoke(context);
            }
            catch (Exception ee)
            {
                var str = string.Join(",", parameters.Select(p => $"{p.Key}:{p.Value}"));
                //throw new Exception(ErrorStr.FormatWith(expression, str), ee);
            }
        }
		
}

public class CustomExpressions
    {
        //static readonly LittleEndianBitConverter leBitConverter = new LittleEndianBitConverter();
        //static readonly BigEndianBitConverter beBitConverter = new BigEndianBitConverter();
        /// <summary>
        /// 
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public int bcd(byte[] stream, int offset, int len)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            var temp = new StringBuilder(len * 2);

            for (var i = 0; i < len; i++)
            {
                int b = stream[offset++];

                if ((byte)((b & 0xf0) >> 4) == 0x0f)
                {
                    continue;
                }

                temp.Append(((b & 0xf0) >> 4));

                if (((byte)(b & 0x0f) == 0x0f))
                {
                    continue;
                }

                temp.Append(b & 0x0f);
            }

            if (temp.Length != 0)
            {
                return int.Parse(temp.ToString().Substring(0, 1).Equals("0") ? temp.ToString().Substring(1) : temp.ToString());
            }

            return 0;
        }

        //int8(name) - signed 8 bit integer
        public short int8(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return unchecked((sbyte)stream[offset]);
        }

        //sint8(name) - signed 8 bit integer
        public short sint8(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return unchecked((sbyte)stream[offset]);
        }

        //uint8(name) - unsigned 8 bit integer
        public short uint8(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return stream[offset];
        }

        //int16(name) - signed, little endian 16 bit integer
        public short int16(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt16(stream, offset);
        }

        //int16le(name) - signed, little endian 16 bit integer
        public short int16le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt16(stream, offset);
        }

        //int16be(name) - signed, big endian 16 bit integer
        public short int16be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToInt16(stream, offset);
        }

        //sint16(name) - signed, little endian 16 bit integer
        public short sint16(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt16(stream, offset);
        }

        //sint16le(name) - signed, little endian 16 bit integer
        public short sint16le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt16(stream, offset);
        }

        //sint16be(name) - signed, big endian 16 bit integer
        public short sint16be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToInt16(stream, offset);
        }

        //uint16(name) - unsigned, little endian 16 bit integer
        public ushort uint16(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToUInt16(stream, offset);
        }

        //uint16le(name) - unsigned, little endian 16 bit integer
        public ushort uint16le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToUInt16(stream, offset);
        }

        //uint16be(name) - unsigned, big endian 16 bit integer
        public ushort uint16be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToUInt16(stream, offset);
        }

        //int32(name) - signed, little endian 32 bit integer
        public int int32(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt32(stream, offset);
        }

        //int32le(name) - signed, little endian 32 bit integer
        public int int32le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt32(stream, offset);
        }

        //int32be(name) - signed, big endian 32 bit integer
        public int int32be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToInt32(stream, offset);
        }

        //sint32(name) - signed, little endian 32 bit integer
        public int sint32(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt32(stream, offset);
        }

        //sint32le(name) - signed, little endian 32 bit integer
        public int sint32le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt32(stream, offset);
        }

        //sint32be(name) - signed, big endian 32 bit integer
        public int sint32be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToInt32(stream, offset);
        }

        //uint32(name) - unsigned, little endian 32 bit integer
        public uint uint32(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToUInt32(stream, offset);
        }

        //uint32le(name) - unsigned, little endian 32 bit integer
        public uint uint32le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToUInt32(stream, offset);
        }

        //uint32be(name) - unsigned, big endian 32 bit integer
        public uint uint32be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToUInt32(stream, offset);
        }

        //int64(name) - signed, little endian 64 bit integer
        public long int64(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt64(stream, offset);
        }

        //int64le(name) - signed, little endian 64 bit integer
        public long int64le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt64(stream, offset);
        }

        //int64be(name) - signed, big endian 64 bit integer
        public long int64be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToInt64(stream, offset);
        }

        //sint64(name) - signed, little endian 64 bit integer
        public long sint64(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt64(stream, offset);
        }

        //sint64le(name) - signed, little endian 64 bit integer
        public long sint64le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToInt64(stream, offset);
        }

        //sint64be(name) - signed, big endian 64 bit integer
        public long sint64be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToInt64(stream, offset);
        }

        //uint64(name) - unsigned, little endian 64 bit integer
        public ulong uint64(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToUInt64(stream, offset);
        }

        //uint64le(name) - unsigned, little endian 64 bit integer
        public ulong uint64le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToUInt64(stream, offset);
        }

        //uint64be(name) - unsigned, big endian 64 bit integer
        public ulong uint64be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToUInt64(stream, offset);
        }

        //floatbe(data) - big endian 32 bit float
        public float floatbe(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToSingle(stream, offset);
        }

        //floatle(data) - little endian 32 bit float
        public float floatle(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToSingle(stream, offset);
        }

        //doublebe(data) - big endian 64 bit double
        public double doublebe(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return beBitConverter.ToDouble(stream, offset);
        }

        //doublele(data) - little endian 64 bit double
        public double doublele(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            return leBitConverter.ToDouble(stream, offset);
        }

        public string ascii(byte[] stream, int offset, int len)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            // Replace any null char with empty string.
            // We have seen cases where null char in UTF8 strings are not handled (e.g. postgres)
            // There may be other chars we need to handle some day but I don't know what those are right now.
            return Regex.Replace(new string(Encoding.ASCII.GetChars(stream, offset, len)), "\x00", string.Empty);
        }

        public string s7scldt(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;

            int year = stream[offset + 0].AsBcd() + 2000;
            int month = stream[offset + 1].AsBcd();
            int day = stream[offset + 2].AsBcd();
            int hour = stream[offset + 3].AsBcd();
            int minute = stream[offset + 4].AsBcd();
            int second = stream[offset + 5].AsBcd();

            string milisecString1 = stream[offset + 6].AsBcd().ToString(CultureInfo.InvariantCulture);
            int milisecByte2 = stream[offset + 7] >> 4;
            string milisecString2 = ((byte)(milisecByte2)).AsBcd().ToString(CultureInfo.InvariantCulture);
            double milisecond = short.Parse(milisecString1 + milisecString2);

            DateTime dTimePrlim = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc);
            DateTime dT = dTimePrlim.AddMilliseconds(milisecond);

            return dT.ToString(CultureInfo.InvariantCulture);
        }
}


 public static class NumericExtensions
    {
        public static bool Between(this float value, float a, float b)
        {
            return value >= a && value <= b;
        }

        public static bool Between(this decimal value, decimal a, decimal b)
        {
            return value >= a && value <= b;
        }

        public static bool Between(this byte value, byte a, byte b)
        {
            return value >= a && value <= b;
        }

        public static bool Between(this short value, short a, short b)
        {
            return value >= a && value <= b;
        }
        
        public static bool Between(this ushort value, ushort a, ushort b)
        {
            return value >= a && value <= b;
        }

        public static bool Between(this int value, int a, int b)
        {
            return value >= a && value <= b;
        }
        
        public static bool Between(this uint value, uint a, uint b)
        {
            return value >= a && value <= b;
        }

        public static bool Between(this double value, double a, double b)
        {
            return value >= a && value <= b;
        }

        public static bool Between(this long value, long a, long b)
        {
            return value >= a && value <= b;
        }
        
        public static bool Between(this ulong value, ulong a, ulong b)
        {
            return value >= a && value <= b;
        }

        /// <summary>
        /// Rotating Bit Shift Right
        /// </summary>
        /// <param name="input">Bitmask source</param>
        /// <param name="sizeInBits">Length in bits for rotation</param>
        /// <param name="places">Number of bits to shift</param>
        /// <returns>Shifted number</returns>
        public static int Ror(this int input, int sizeInBits, int places)
        {
            return ((input >> places) | (input << (sizeInBits - places))) & (int)Math.Pow(2, sizeInBits) - 1;
        }

        /// <summary>
        /// Rotating Bit Shift Left
        /// </summary>
        /// <param name="input">Bitmask source</param>
        /// <param name="sizeInBits">Length in bits for rotation</param>
        /// <param name="places">Number of bits to shift</param>
        /// <returns>Shifted number</returns>
        public static int Rol(this int input, int sizeInBits, int places)
        {
            return ((input << places) | (input >> (sizeInBits - places))) & (int)Math.Pow(2, sizeInBits) - 1;
        }

        public static bool AlmostEquals(this double double1, double double2, double precision)
        {
            return (Math.Abs(double1 - double2) <= precision);
        }

        public static bool AlmostEquals(this float float1, float float2, float precision)
        {
            return (Math.Abs(float1 - float2) <= precision);
        }

        public static int AsBcd(this byte value)
        {
            int high = value >> 4;
            int low = value & 0xF;

            return 10 * high + low;
        }
    }

​x
 
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Expressions;
​
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello World");
        
    }
    
        public void Evaluate(string expression, Dictionary<string, object> parameters)
        {
            CustomExpressions Lib = new CustomExpressions();
            
            //to make this backwards compatible with ncalc, we must remove [] params
            expression = expression.Replace("[", string.Empty);
            expression = expression.Replace("]", string.Empty);
​
            var e = new DynamicExpression(expression, ExpressionLanguage.Csharp);
            var context = new ExpressionContext { Owner = Lib };
            context.Imports.Add(new Import(typeof(Math)));
​
            foreach (var parameter in parameters)
            {
                context.Variables.Add(parameter.Key, parameter.Value);
            }
​
            try
            {
                e.Invoke(context);
            }
            catch (Exception ee)
            {
                var str = string.Join(",", parameters.Select(p => $"{p.Key}:{p.Value}"));
                //throw new Exception(ErrorStr.FormatWith(expression, str), ee);
            }
        }
        
}
​
public class CustomExpressions
    {
        //static readonly LittleEndianBitConverter leBitConverter = new LittleEndianBitConverter();
        //static readonly BigEndianBitConverter beBitConverter = new BigEndianBitConverter();
        /// <summary>
        /// 
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public int bcd(byte[] stream, int offset, int len)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            var temp = new StringBuilder(len * 2);
​
            for (var i = 0; i < len; i++)
            {
                int b = stream[offset++];
​
                if ((byte)((b & 0xf0) >> 4) == 0x0f)
                {
                    continue;
                }
​
                temp.Append(((b & 0xf0) >> 4));
​
                if (((byte)(b & 0x0f) == 0x0f))
                {
                    continue;
                }
​
                temp.Append(b & 0x0f);
            }
​
            if (temp.Length != 0)
            {
                return int.Parse(temp.ToString().Substring(0, 1).Equals("0") ? temp.ToString().Substring(1) : temp.ToString());
            }
​
            return 0;
        }
​
        //int8(name) - signed 8 bit integer
        public short int8(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return unchecked((sbyte)stream[offset]);
        }
​
        //sint8(name) - signed 8 bit integer
        public short sint8(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return unchecked((sbyte)stream[offset]);
        }
​
        //uint8(name) - unsigned 8 bit integer
        public short uint8(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return stream[offset];
        }
​
        //int16(name) - signed, little endian 16 bit integer
        public short int16(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt16(stream, offset);
        }
​
        //int16le(name) - signed, little endian 16 bit integer
        public short int16le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt16(stream, offset);
        }
​
        //int16be(name) - signed, big endian 16 bit integer
        public short int16be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToInt16(stream, offset);
        }
​
        //sint16(name) - signed, little endian 16 bit integer
        public short sint16(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt16(stream, offset);
        }
​
        //sint16le(name) - signed, little endian 16 bit integer
        public short sint16le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt16(stream, offset);
        }
​
        //sint16be(name) - signed, big endian 16 bit integer
        public short sint16be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToInt16(stream, offset);
        }
​
        //uint16(name) - unsigned, little endian 16 bit integer
        public ushort uint16(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToUInt16(stream, offset);
        }
​
        //uint16le(name) - unsigned, little endian 16 bit integer
        public ushort uint16le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToUInt16(stream, offset);
        }
​
        //uint16be(name) - unsigned, big endian 16 bit integer
        public ushort uint16be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToUInt16(stream, offset);
        }
​
        //int32(name) - signed, little endian 32 bit integer
        public int int32(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt32(stream, offset);
        }
​
        //int32le(name) - signed, little endian 32 bit integer
        public int int32le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt32(stream, offset);
        }
​
        //int32be(name) - signed, big endian 32 bit integer
        public int int32be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToInt32(stream, offset);
        }
​
        //sint32(name) - signed, little endian 32 bit integer
        public int sint32(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt32(stream, offset);
        }
​
        //sint32le(name) - signed, little endian 32 bit integer
        public int sint32le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt32(stream, offset);
        }
​
        //sint32be(name) - signed, big endian 32 bit integer
        public int sint32be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToInt32(stream, offset);
        }
​
        //uint32(name) - unsigned, little endian 32 bit integer
        public uint uint32(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToUInt32(stream, offset);
        }
​
        //uint32le(name) - unsigned, little endian 32 bit integer
        public uint uint32le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToUInt32(stream, offset);
        }
​
        //uint32be(name) - unsigned, big endian 32 bit integer
        public uint uint32be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToUInt32(stream, offset);
        }
​
        //int64(name) - signed, little endian 64 bit integer
        public long int64(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt64(stream, offset);
        }
​
        //int64le(name) - signed, little endian 64 bit integer
        public long int64le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt64(stream, offset);
        }
​
        //int64be(name) - signed, big endian 64 bit integer
        public long int64be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToInt64(stream, offset);
        }
​
        //sint64(name) - signed, little endian 64 bit integer
        public long sint64(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt64(stream, offset);
        }
​
        //sint64le(name) - signed, little endian 64 bit integer
        public long sint64le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToInt64(stream, offset);
        }
​
        //sint64be(name) - signed, big endian 64 bit integer
        public long sint64be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToInt64(stream, offset);
        }
​
        //uint64(name) - unsigned, little endian 64 bit integer
        public ulong uint64(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToUInt64(stream, offset);
        }
​
        //uint64le(name) - unsigned, little endian 64 bit integer
        public ulong uint64le(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToUInt64(stream, offset);
        }
​
        //uint64be(name) - unsigned, big endian 64 bit integer
        public ulong uint64be(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToUInt64(stream, offset);
        }
​
        //floatbe(data) - big endian 32 bit float
        public float floatbe(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToSingle(stream, offset);
        }
​
        //floatle(data) - little endian 32 bit float
        public float floatle(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToSingle(stream, offset);
        }
​
        //doublebe(data) - big endian 64 bit double
        public double doublebe(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return beBitConverter.ToDouble(stream, offset);
        }
​
        //doublele(data) - little endian 64 bit double
        public double doublele(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            return leBitConverter.ToDouble(stream, offset);
        }
​
        public string ascii(byte[] stream, int offset, int len)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            // Replace any null char with empty string.
            // We have seen cases where null char in UTF8 strings are not handled (e.g. postgres)
            // There may be other chars we need to handle some day but I don't know what those are right now.
            return Regex.Replace(new string(Encoding.ASCII.GetChars(stream, offset, len)), "\x00", string.Empty);
        }
​
        public string s7scldt(byte[] stream, int offset)
        {
            //make offset 0 based for .net operations
            offset = offset - 1;
​
            int year = stream[offset + 0].AsBcd() + 2000;
            int month = stream[offset + 1].AsBcd();
            int day = stream[offset + 2].AsBcd();
            int hour = stream[offset + 3].AsBcd();
            int minute = stream[offset + 4].AsBcd();
            int second = stream[offset + 5].AsBcd();
​
            string milisecString1 = stream[offset + 6].AsBcd().ToString(CultureInfo.InvariantCulture);
            int milisecByte2 = stream[offset + 7] >> 4;
            string milisecString2 = ((byte)(milisecByte2)).AsBcd().ToString(CultureInfo.InvariantCulture);
            double milisecond = short.Parse(milisecString1 + milisecString2);
​
            DateTime dTimePrlim = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc);
            DateTime dT = dTimePrlim.AddMilliseconds(milisecond);
​
            return dT.ToString(CultureInfo.InvariantCulture);
        }
}
​
​
 public static class NumericExtensions
    {
        public static bool Between(this float value, float a, float b)
        {
            return value >= a && value <= b;
        }
​
        public static bool Between(this decimal value, decimal a, decimal b)
        {
            return value >= a && value <= b;
        }
​
        public static bool Between(this byte value, byte a, byte b)
        {
            return value >= a && value <= b;
        }
​
        public static bool Between(this short value, short a, short b)
        {
            return value >= a && value <= b;
        }
        
        public static bool Between(this ushort value, ushort a, ushort b)
        {
            return value >= a && value <= b;
        }
​
        public static bool Between(this int value, int a, int b)
        {
            return value >= a && value <= b;
        }
        
        public static bool Between(this uint value, uint a, uint b)
        {
            return value >= a && value <= b;
        }
​
        public static bool Between(this double value, double a, double b)
        {
            return value >= a && value <= b;
        }
​
        public static bool Between(this long value, long a, long b)
        {
            return value >= a && value <= b;
        }
        
        public static bool Between(this ulong value, ulong a, ulong b)
        {
            return value >= a && value <= b;
        }
​
        /// <summary>
        /// Rotating Bit Shift Right
        /// </summary>
        /// <param name="input">Bitmask source</param>
        /// <param name="sizeInBits">Length in bits for rotation</param>
        /// <param name="places">Number of bits to shift</param>
        /// <returns>Shifted number</returns>
        public static int Ror(this int input, int sizeInBits, int places)
        {
            return ((input >> places) | (input << (sizeInBits - places))) & (int)Math.Pow(2, sizeInBits) - 1;
        }
​
        /// <summary>
        /// Rotating Bit Shift Left
        /// </summary>
        /// <param name="input">Bitmask source</param>
        /// <param name="sizeInBits">Length in bits for rotation</param>
        /// <param name="places">Number of bits to shift</param>
        /// <returns>Shifted number</returns>
        public static int Rol(this int input, int sizeInBits, int places)
        {
            return ((input << places) | (input >> (sizeInBits - places))) & (int)Math.Pow(2, sizeInBits) - 1;
        }
​
        public static bool AlmostEquals(this double double1, double double2, double precision)
        {
            return (Math.Abs(double1 - double2) <= precision);
        }
​
        public static bool AlmostEquals(this float float1, float float2, float precision)
        {
            return (Math.Abs(float1 - float2) <= precision);
        }
​
        public static int AsBcd(this byte value)
        {
            int high = value >> 4;
            int low = value & 0xF;
​
            return 10 * high + low;
        }
    }
​
​
​

View IL Code