Several little improvements and minor functionality extending

[Mrnikbobjeff]

added the necessary code to check whether Spotify.exe and SpotifyWebHelper.exe actually exist and code which checks the location of SpotifyWebHelper.exe as mentioned in #48
replaced all occurances of checking whether a string is empty via str == ""; with String.IsNullOrEmpty(str);

sealed StringAttribute because it is only contains Text as an attribute
sealed SpotifyWebAPI class because it implements IDisposable
changed Exception catching where the Exception is not used to ignore the Exception object
removed Console.WriteLine("Exception: " + e.Message) in HttpProcessor.Process as it is a library function which might not be used in a console application
added capital letters for the first word in 3 Exception constructors
changed ruleset back to Microsoft Managed Recommended Rules

removed nircmd.dll and replaced internal mute function calls with the IAudioSession interface which works on Windows 7 or newer, #26 is solved by this
Added advanced volume control for spotify's volume mixer

beautified the code via codemaid to improve readability

[JohnnyCrazy]

Wow, thanks for this PR, nice changes! 🌟
Will review them somewhere in the next days, but already looks good! :)

[JohnnyCrazy]

So, after reading a bit about Contracts, I'm unsure if it's worth using here while we still have some normal "if-throw-else"-statements. So why did you chose this over "if-throw-else"-statements? Any particular reason?

[Mrnikbobjeff]

The main reason for using Contracts was the option to immediately throw an Exception if an argument is invalid. I became accustomed to it, in hindsight I should have stayed with if-throw-else. The main advantage for continuous Contract usage is the possibility to combine it with IntelliSense

[JohnnyCrazy]

Mh, I actually like the idea, but I wonder if it's good to put it in a library. ("if-throw-else" seems to be a more general solution, let me think and research a bit about it before changing 👍 )

[Mrnikbobjeff]

The wikipedia article describes DbC really well, here is the link: https://en.wikipedia.org/wiki/Design_by_contract

[Mrnikbobjeff]

So, any idea when this will be merged? I am currently working on a separate implementation of JSON.net, which could possibly remove the dependency, thus making the library a standalone module. I would like to create a new branch for that, but I will only start implementing it here once the existing pull request is merged.

[JohnnyCrazy]

Will do shortly.

Regarding json.Net:
I actually would like to keep it. It's well tested, widely used and you just need it in a lot of cases. An own implementation could lead to problems.

[JohnnyCrazy]

Any reason for this call? @Mrnikbobjeff

[Mrnikbobjeff]

When implementing the dispose pattern you might also add a finalizer to your class that calls Dispose(). This is to make sure that Dispose() always gets called, even if a client forgets to call it.

To prevent the dispose method from running twice (in case the object already has been disposed) you add GC.SuppressFinalize(this);. The documentation provides a sample:

class MyResource : IDisposable
{

// This destructor will run only if the Dispose method 
// does not get called.
~MyResource()      
{
    // Do not re-create Dispose clean-up code here.
    // Calling Dispose(false) is optimal in terms of
    // readability and maintainability.
    Dispose(false);
}

// Implement IDisposable.
// Do not make this method virtual.
// A derived class should not be able to override this method.
public void Dispose()
{
    Dispose(true);
    // This object will be cleaned up by the Dispose method.
    // Therefore, you should call GC.SupressFinalize to
    // take this object off the finalization queue 
    // and prevent finalization code for this object
    // from executing a second time.
    GC.SuppressFinalize(this);
}

private void Dispose(bool disposing)
{
    // Check to see if Dispose has already been called.
    if(!this.disposed)
    {
        // If disposing equals true, dispose all managed 
        // and unmanaged resources.
        if(disposing)
        {
            // Dispose managed resources.
            component.Dispose();
        }

        // Call the appropriate methods to clean up 
        // unmanaged resources here.
        resource.Cleanup()          
    }
    disposed = true;         
}

}