MV Share Store Library
Ever since Windows NT Microsoft has (quite rightly) not let Windows processes share memory address space it has obviously been much more difficult for applications and processes to share data without using files on disk or some form of networking. This is excellent news with regard to application stability and data integrity but less good if you have applications or processes that actually want to share their information. There are ways of course: TCP/IP, Named Pipes & Memory Mapped files to name a few but none of them are particularly easy or intuitive to use. The MV Share Store is a library (dll) that enables the packaging and sharing of data between processes.
The MV Share Store itself consists of a Windows 10 / 11 (64bit & 32bit) .NET C# DLL (with associated IntelliSense API commenting) that can be simply added to an MS Visual Studio project as a reference and used directly by your code to create, share and store packs of data containing any number of variables of various supported types that can either be accessed by name or by index. These packs, which can also be used internally within applications, can be added to, deleted from, inserted into etc. as well as being shared between processes and saved to files on disk.
Also included here are two complete but fairly basic sample projects, complete with source code, to demonstrate how the Library can be used and some of its capabilities. There is a Data Server which can manage the Share Store memory areas if required as well as create and maintain data packs, optionally post / publish them to the shared list and area as well as saving them to disk. The other application is a Data Client which lists all the data shares that have been posted and are available and can open and if required manipulate them and repost them back. These sample application projects can be opened in MS Visual Studio and used to demonstrate the Library's capabilities. They can also be used as a basis for further development if desired.
Library Capabilities
The building blocks of the MV Share Store Library are DataPacks. These are collections of DataItems each of which can be of any of the following DataTypes:
- bool (Bool) - Boolean value
- byte (Byte) - Byte (unsigned 8 bit integer) values = 0 - 255
- char (Char) - Char (16 bit) values = U+0000 to U+FFFF
- short (Short) - Short (signed 16 bit integer) values = -32,768 to 32,767
- int (Int) - Int (signed 32 bit integer) values = -2,147,483,648 to 2,147,483,647
- long (Long) - Long (signed 64-bit integer) values = -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
- float (Float) - Float (4 byte numeric) values = ~6-9 digits
- double (Double) - Double (8 byte numeric) values = ~15-17 digits
- decimal (Decimal) - Decimal (16 byte numeric) values = ~28-29 digits
- string (String) - String value
- DataPack (Datapack) - A nested / embedded DataPack
These DataItems can optionally be named (and if so the name must be unique) and accessed by their name. All the DataItems, named or not can be accessed using their index into the DataPack.
You can add to, delete and insert DataItems in a DataPack. DataPacks can also be sorted and merged as well as being converted into DataShares and DataStores (see below).
Among the additional possible uses for DataPacks are:
- Act as a set of Name / Value pairs
- Act as a container / collection of data items of disparate types
- Act as a composite return value from a function returning multiple variables of different types
- Act as a composite function parameter containing multiple variables of different types
- Used as a 'state machine' to communicate between a running thread and the process that owns it
- Used for any internal communication involving sets of disparate variables
- Nested DataPacks can be used in place of arrays of variables
Both DataShares and DataStores are derived from DataPacks and so inherit all their capabilities. However both of these data packaging classes implement additional functionality of their own.
DataPacks can now contain other DataPacks and these can be nested / embedded as deeply as desired. This enables them to be used to define data at any number of different levels. Obviously DataShares and DataStores also support DataItems of type DataPack.
DataStores also implement the ability to be saved to files on disk and then read back again. This is useful for making permanent copies of the data but it also means they can be used for such things as storing application settings and state information.
DataShares are probably the main use for DataPacks and the main focus of this Library. These have the capability of being published / posted to a global ShareStore which then makes them available to other MV Share Store enabled programs to open and optionally update. Posted DataShares are published in a Share List that can be interrogated and used to open the desired DataShare using it's name or ID (by default over 5,000 DataShares can be created and listed in a single ShareStore).
All DataShares have a unique ID assigned to them and can optionally be named to help identify them. They can also be marked as being Read Only which means that none of the programs or processes accessing it can make any changes to it. If changes are made to a (non Read Only) DataShare then it is marked as being dirty and its date/timestamp updated. DataShares can also be locked by a process so that no other processes can change it until it is unlocked.
DataShares can also be assigned to an Owner / Group and if they are then marked as being Private then only processes that also run under / use that Owner or Group are allowed to view or modify them (although it should be noted that this capability is intended more as an assistance rather than as a strict privacy feature).
The supplied simple Data Server program can be used to create, open and maintain ShareStores, DataPacks, DataShares and DataStores. The supplied basic Data Client can be used to access and update any published DataShares and read and write DataStores.