Simplest approach for creating database for small collection of data - new project design phase

Question

Hello. I am at the design stage of a VB.NET project, which I hope will help me strengthen some skills I have learnt so far, and learn new ones. I have a couple of questions. Firstly regarding data types, is there a unified, standardised, all-convergent
data type available I can use? Secondly I've read about numerous avenues to create a database, namely binary serialisation, access-based, excel-based, notepad-based - The project I intend to create, will only require storage of a "relatively" small
collection of data, which may grow over time, but not significantly - so, taking this into account, which method is advisable for creating my database? (a beginner-friendly option is preferred). I have included a couple of images, with my questions, to give
a rough idea of what I'm planning to do. Thanks for your advice and suggestions.

Answer 1

Type would be the type of recording, as in LP (Long Play - standard album), EP (Extended Play) or Compilation. Most would be LP.
Chris,
I have a start on this and I want to pause here to post what I have and to discuss it.
There’s a lot to talk about because you’re going from little knowledge of a class to a lot in a hurry. There is no real hurry
in any of this; if you don’t understand then let’s stop and talk about it – until you fully have a handle on it, adding more would only fuel the confusion.
I’ll add this at this juncture: There is no one single right way to do this. There are definitely some
wrong
(or maybe just simply ineffectual) ways, but certainly no single right way. A lot of what you’ll see in the following will reflect my preference; nothing more than that.
Also though, I’m doing some of this to expose you to it. By that I mean that I may or may not have done it this way all along,
but I decided that I want to open the doors, even though at first it’ll seem like you’re trying to get a drink of water from a fire hydrant. ;-)
I have it set up with two namespaces: CMJR and Common. The latter one is for use for what I’m considering to be a ‘common’ need
– things that you may use in several classes. In time, the routines for serialization will be there but no need to even talk about that now so it’s not there.
The code so far (which I’ll show by the end of this discourse) is about 500 lines. For a class library, that’s puny! Most of
what I have thus far is just a shell of what will be filled in later. I won’t at all be surprised that by time this is completed, that 500 lines can easily grow to 5000 lines or more.
Like I said yesterday, the great thing about doing it this way is that it’s done
your
way; the drawback is just how much there is to do though, so if nothing else, this will perhaps influence your decision on how you want to handle things like this in the future.
The namespaces/classes are laid out as:
CMJR
Music (a class)
Film (a class)
Games (a class)
Common
IDataSource (an interface)
IGenre (an interface)
Utilities (a class)
This
image shows the structure of things thus far. The reason why the enum “GenreType” isn’t expanded in that
image is because it’s hugely long! In fact I fully expect that you’ll likely delete most of those. I got them from someone else’s class library (about a decade ago) so it was convenient to use.
Let’s start from the inside and work toward the outside here:
What is an
enum?
An enum (enumeration) is a type all its own. It’s a constant (of integral type) that you define. You can think of it as “an
integer with a name associated with it” because in code, you’ll use it like a multiple-choice selection and [typically] you’ll use its name.
Any time there’s a need for some something to be “this or that”, an enum very often is a useful type to use. In what we talked
about yesterday regarding what the source of the data is (CD or PC), that’s what came to mind; select which of the two from an enum. I always include a “_String” property with these so that it can later be used in whatever will consume the class. Often it’s
nothing more than use the .ToString method of the enum itself, but remember that then enum is actually an integer, not a string.
In this library so far, I have three enums defined. Two of those are in each of two interfaces (discussed in a bit) and one
is specifically related to only the music, so it’s in the class “Music”:
       Public Enum MusicFrom
           LP
           EP
           Compilation
       End Enum
The “type” that I asked about earlier is encompassed in that enum and you can more or less see how it works without any further
explanation.
Do understand that enum is only ‘useful’ for programming. We could use strings for all that it matters, but the problem with
doing that are many, including things like typos and capitalization. That’s not the case with an enum because you select one of the choices offered. In the one above, that would be either LP, EP, or Compilation. It can’t be anything else.
So if strings have this issue with typo’s and the like, what about if we just assigned it a number (an integer). Sure that’s
a better idea but are you really going to remember what 23 means? I doubt it, or not for long.
BUT – if we had a number that has a string associated with it, yea that’s a good idea!
Right! Now you know what an enum is. ;-)
Notice from the
class
diagram though – it’s not shown; I’m not using it all and that’s because I question its worth here, at least
for the current setup. I’ll explain what I mean:
As it’s currently set up, the basic unit of the class “Music” is a song. Even though there’s a title for the album, the album
– as a type – doesn’t exist. LP, EP, and Compilation refer to the album, not the song (in my opinion here) so I don’t see how it can be used.
If, however, we create a new type called “Album”, then I can see how it could be used. In something I worked on a while back
that’s exactly how I have it set up: An album is a “container for songs” and the album (a class in what I’m referring to from a few months back) has certain properties like a name and cover art, etc..
I don’t have this set up that way, but give that some thought.
What is an
interface?
Until quite recently I ‘knew of them’ but I never used them. There may or may not be merit in it here either but I wanted to
expose you to them.
From that link above:
“An
interface defines a set of members, such as properties and procedures, that classes and structures can implement. The interface defines only the signatures of the members and not their internal workings.”
The interface is a way in which you create a ‘code contract’. You don’t define what the methods, properties and events do in
the interface – you define that they have to be implemented if a class uses it.
It’s up to the class to actually put it to use (i.e., the code that’s executed in the member of the interface).
It’s a lot deeper than I’m discussing here – including a fair amount of ambiguity – so I won’t go any further than that for
now.
I have two interfaces set up and I have them in the “Common” namespace. They are “IDataSource” and “IGenre”.
IDataSource has an enum named “SourceType” and two read-only properties (see it later in the code).
The interface IGenre is likewise set up the same way and that’s where the long list of elements are in the enum named “GenreType”
that I talked about earlier.
I think it’s a good idea with Genre that it’s a “pick one of these” rather than simply a string and here’s why: If we later
add in a method to choose songs from a collection of them, one of the options might be of a particular genre. That’s not an uncommon request I would think. By using an enum, we don’t have to worry about your users mistyping when they add the data:
RockAndRoll
Rock and Roll
Rock
…etc., and imagine some of the typos your users might come up with, so by using an enum it’s definitive rather than guessing.
I said that an enum is ‘only for programming though’ so we’ll need to make it more usable later on. For example, I can also
build in methods to hand you back a string array of the string equivalent of those enums and then later a method to turn that string back into the actual enum member. By doing this then the method(s) which will use this will filter the data from the collection
to only include those with that particular genre.
Other than something simple, I’ve learned that once you get involved in a really long enum – like the genre that I showed above
– it’s better to create a class which, all on its own, has methods for handing you the string array and then handling the conversion back to an enum, so that’s a possibility too.
That’s for use in your UI so the blinders will start to come off at that point. ;-)
Continued in a subsequent post…
Still lost in code, just at a little higher level.