IsamDataFileBaseT Class

public abstract class IsamDataFileBase<T> : ISupportLifecycle, 
	IDisposable, IProvideStatus, IPersistSettings
where T : ISupportBinaryImage

Public MustInherit Class IsamDataFileBase(Of T As ISupportBinaryImage)
	Implements ISupportLifecycle, IDisposable, IProvideStatus, IPersistSettings

generic<typename T>
where T : ISupportBinaryImage
public ref class IsamDataFileBase abstract : ISupportLifecycle, 
	IDisposable, IProvideStatus, IPersistSettings

[<AbstractClassAttribute>]
type IsamDataFileBase<'T when 'T : ISupportBinaryImage> = 
    class
        interface ISupportLifecycle
        interface IDisposable
        interface IProvideStatus
        interface IPersistSettings
    end

JavaScript does not support generic types or methods.

using System;
using System.Text;
using GSF;
using GSF.IO;
using GSF.Parsing;

class Program
{
    static void Main(string[] args)
    {
        // Create a few test records.
        TestIsamFileRecord r1 = new TestIsamFileRecord(1);
        r1.Name = "TestRecord1";
        r1.Value = double.MinValue;
        r1.Description = "Test record with minimum double value";
        TestIsamFileRecord r2 = new TestIsamFileRecord(2);
        r2.Name = "TestRecord2";
        r2.Value = double.MaxValue;
        r2.Description = "Test record with maximum double value";

        // Open ISAM file.
        TestIsamFile testFile = new TestIsamFile();
        testFile.FileName = "TestIsamFile.dat";
        testFile.Open();

        // Write test records.
        testFile.Write(r1.Index, r1);
        testFile.Write(r2.Index, r2);

        // Read test records.
        Console.WriteLine(testFile.Read(1));
        Console.WriteLine(testFile.Read(2));

        // Close ISAM file.
        testFile.Close();

        Console.ReadLine();
    }
}

class TestIsamFile : IsamDataFileBase<TestIsamFileRecord>
{
    /// <summary>
    /// Size of a single file record.
    /// </summary>
    protected override int GetRecordSize()
    {
        return TestIsamFileRecord.RecordLength;
    }

    /// <summary>
    /// Creates a new empty file record.
    /// </summary>
    protected override TestIsamFileRecord CreateNewRecord(int id)
    {
        return new TestIsamFileRecord(id);
    }
}

class TestIsamFileRecord : ISupportBinaryImage
{
    private int m_index;
    private string m_name;                  // 20  * 1 =  20
    private double m_value;                 // 1   * 8 =   8
    private string m_description;           // 100 * 1 = 100

    public const int RecordLength = 128;    // Total   = 128

    public TestIsamFileRecord(int recordIndex)
    {
        m_index = recordIndex;

        Name = string.Empty;
        Value = double.NaN;
        Description = string.Empty;
    }

    /// <summary>
    /// 1-based index of the record.
    /// </summary>
    public int Index
    {
        get { return m_index; }
    }

    /// <summary>
    /// Name of the record.
    /// </summary>
    public string Name
    {
        get { return m_name; }
        set { m_name = value.TruncateRight(20).PadRight(20); }
    }

    /// <summary>
    /// Value of the record.
    /// </summary>
    public double Value
    {
        get { return m_value; }
        set { m_value = value; }
    }

    /// <summary>
    /// Description of the record.
    /// </summary>
    public string Description
    {
        get { return m_description; }
        set { m_description = value.TruncateRight(100).PadRight(100); }
    }

    /// <summary>
    /// Serialized record length.
    /// </summary>
    public int BinaryLength
    {
        get { return RecordLength; }
    }

    /// <summary>
    /// Serialized record data.
    /// </summary>
    public byte[] BinaryImage
    {
        get
        {
            // Serialize TestIsamFileRecord into byte array.
            byte[] image = new byte[RecordLength];
            Buffer.BlockCopy(Encoding.ASCII.GetBytes(Name), 0, image, 0, 20);
            Buffer.BlockCopy(BitConverter.GetBytes(Value), 0, image, 20, 8);
            Buffer.BlockCopy(Encoding.ASCII.GetBytes(Description), 0, image, 28, 100);

            return image;
        }
    }

    /// <summary>
    /// Deserializes the record.
    /// </summary>
    public int Initialize(byte[] binaryImage, int startIndex, int length)
    {
        if (length >= RecordLength)
        {
            // Deserialize byte array into TestIsamFileRecord.
            Name = Encoding.ASCII.GetString(binaryImage, startIndex, 20);
            Value = BitConverter.ToDouble(binaryImage, startIndex + 20);
            Description = Encoding.ASCII.GetString(binaryImage, startIndex + 28, 100);
        }
        else
            throw new InvalidOperationException("Invalid record size, not enough data to deserialize record"); 

        return RecordLength;
    }

    /// <summary>
    /// String representation of the record.
    /// </summary>
    public override string ToString()
    {
        return string.Format("Name: {0}, Value: {1}, Description: {2}", Name, Value, Description);
    }
}