What is rskibbe.Core.Composition?

My NuGet package called „rskibbe.Core.Composition“ is about helping you build more complex objects easier. It provides a common infrastructure for you to design your classes upon. It was private at first, but I’m using it in a lot of my projects, so I thought, why wouldn’t I publish it.

If you need more info on how it’s done behind the scenes, feel free to scroll further down. In a section at the bottom, I’ve provided more detailed explanation on this package. This way you can comprehend the idea behind everything a bit more and maybe even extend on it.

I’ve also added some small class diagram to have everything visually summarized and in one simple spot.

Quick example

Step 1 – Install the package

Open the NuGet Package Manager and execute the following commands (or install it by GUI). This command will install the package to enable you using its interfaces and classes.

Install-Package rskibbe.Core.Composition

Step 2 – Start composing components

Now you are already ready to go and start composing your own components / classes. Please move to the detailed explanation further down to get a better hang of the package.

public class MyComponent : Component
{

   // add different sub-components to your class
   // extend it e. g. with interfaces delegating their actions to
   // the corresponding sub-components

}

Public Class MyComponent
        Inherits Component

   ' add different sub-components to your class
   ' extend it e. g. with interfaces delegating their actions to
   ' the corresponding sub-components

End Class

Using composition over inheritance is the deal, right?

When creating your classes there can be different scenarios where you sometimes need different approaches to solve designing them. Fore sure, we could like mostly use typical inheritance like „a robot is a machine“ – but what if those machines are so damn (pardon me) complex, that you can’t fit them the right way by inheriting? This is where a typical composition scenario could fit for you!

To get to know more about the „composition over inheritance pattern“, I will write a separate blog post, but for now this post here is about my corresponding NuGet package „rskibbe.Core.Composition“. This way, you will have a common denominator where you can build upon and you don’t have to start from scratch as well.

Detailed explanation

The core conception

When designing or – in other words – composing your object of desire, I found it pretty matching, to call the absolute „base“ actually „IComposable„. It’s something you can almost magically compose out of different objects which then builds a new object – what I’m calling an „IComponent„. So basically the „IComponent“ interface inherits from the „IComspoable“ interface.

To actually do / execute this kind of composition, you will need to be able to dynamically add sub-components to your composable(s). Maybe you want to even dynamically remove the components again? This is why the following methods have been implement in the class „Composable“.

Adding and removing components won’t help much, if you can’t access and use them. So – for sure – and as visually mentioned inside the image above, there are methods to get your sub-components from a „parent“.

Concrete example – A machine

Let’s now start a complete example of our first designed component being composed of composables – what a language-play. Keep in mind, that this actually – just an example, feel free to change it in any way fitting your needs… For this example, we’re taking a machine which could possibly connect many things to itself to use them.

// a base class for some sort of common contextual denominator
class Machine : Composable
{

  public Machine()
  {
    // instantiated automatically - needs an empty constructor
    AddComponent<LightComponent>();
    // manual instantiation, maybe with DI whatever
    var giantPowerBattery = new GiantPowerBattery();
    var laserBeamComponent = new LaserBeamComponent(giantPowerBattery);
    AddComponent(laserBeamComponent);
  }

}

// component 1
class LightComponent : Component
{

    public void Toggle() { /* some code.. */ }
    public void TurnOn() { /* some code.. */ }
    public void TurnOff() { /* some code */ }

}

// component 2
class LaserBeamComponent: Component
{

    IEnergySource _energySource;

    // having a ctor with dependency
    public LaserBeamComponent(IEnergySource energySource)
    {
        _energySource = energySource;
    }

    public void Shoot() { // some code.. }

}

// just some helper stuff..
interface IEnergySource { /* .. */ }

class GiantPowerBattery : IEnergySource { /* .. */ }

Using the sub-components

Above, we just provided the composition side of things while composing our machine, but we didn’t actually use anything. If a machine wants to „shoot“ with our „LaserBeamComponent“ or if it wants to toggle the lights, it has to resolve the corresponding thing and use it. So we could just write something like this:

class Machine : Composable
{

  // rest of the machine code from above

  public void ToggleLight()
  {
    var light = GetComponent<LightComponent>();
    light.Toggle();
  }

  // or shorter
  public void ToggleLight2()
    => GetComponent<LightComponent>().Toggle();

  // rest of the machine code from above

}

// somewhere executable
Machine machine = new Machine();
machine.ToggleLight();

// maybe add more things?
// and call them dynamically?

A word on component types

As you’ve probably seen in the example from above here, concrete types were used (in the constructors), like:

AddComponent<LightComponent>();

AddComponent(Of LightComponent)()

The problem is now, that we would have a more strict dependency on the „LightComponent“. I would prefer to rely on abstractions (interfaces) instead. And this is no probem, as you can just use other overloads of the „AddComponent“ method:

class Machine : Composable
{

  public Machine()
  {
    // using an interface alias when calling add
    AddComponent<LightComponent, ILight>

    // or with an instance
    // remember to actually implement the interface here...
    LightComponent light = new LightComponent();
    AddComponent<ILight>(light);
  }

  public void ToggleLight()
    => GetComponent<ILight>().Toggle();

}

interface ILight : IComponent
{
  void Toggle();
  void TurnOn();
  void TurnOff();
}

    interface ILightTrait : IComponent
    {

        public void ToggleLight()
            => GetComponent<ILight>().Toggle();

        public void TurnOnLight()
            => GetComponent<ILight>().TurnOn();

        public void TurnOffLight()
            => GetComponent<ILight>().TurnOff();

    }

After defining that interface, every component – which should have a „Light functionality“ could now just inherit from that interface. That means a machine, a gaming console, whatever could just inherit the functionality from that interface having the possibility to call the defined methods. When having like those 1 liners of methods, it’s no big deal, but as soon as it starts growing, it can make a big difference.

Keep in mind that default implementation style used interfaces require you to use them as interface casted type, not the actual type. Take a look at the following two examples.

Let’s now define two classes which are able to toggle their lights and then use them. Our trait helps us not having to redefine everything from scratch.

    class GamingConsole : Composable, ILightTrait
    {

        public GamingConsole()
        {
            AddComponent<LightComponent, ILightComponent>();
        }

    }

    class Car : Composable, ILightTrait
    {

        public Car()
        {
            AddComponent<LightComponent, ILightComponent>();
        }

    }

    // more...

Now let’s actually use these, care for the warning inside the yellow box from above. You have to cast the object to the interface type to actually use the trait-defined methods.

GamingConsole gamingConsole

// won't work due to how default implementations are usable
gamingConsole.TurnOnLight();

// need's to look like this instead
((ILightTrait)this).TurnOnLight();

Publishing property notifications

When building your complex objects, it could be useful to be able to publish „INotifyPropertyChanged“ notifications. As both classes (Composable and Component) directly or indirectly inherit from „PropertyChangedBase“, you can do so pretty easily by just calling „NotifyOfPropertyChange“. Just provide the changed property name or let it figure it out itself by using the „CallerMemberNameAttribute“.

This could look like the following property implementation:

        bool _isOn;

        public bool IsOn
        {
            get => _isOn;
            set
            {
                if (_isOn == value)
                    return;
                // will automatically use "IsOn" as property name
                NotifyOfPropertyChange();
                // provide a name manually - but in favor with nameof()
                // NotifyOfPropertyChange(nameof(IsOn));
                // or completely manual
                // NotifyOfPropertyChange("IsOn");
            }
        }

Der Beitrag rskibbe.Core.Composition – Building better and more flexible objects erschien zuerst auf Robert Skibbe.

VB.NET Webseite öffnen

In VB.NET eine Webseite öffnen muss nicht schwer sein, obwohl es dafür verschiedene Wege gibt.

Dieser Beitrag hier dient als eine Art Übersicht mit zusätzlichem Content und verschiedenen Ansätzen.

Ebenso weise ich nochmal auf einen blöden Fehler hin, Welchen man natürlich vermeiden möchte!

Awendungsbeispiele

Man kennt es ggf. aus einigen Anwendungen, dass das Web, bzw. der jeweilig installierter Browser mit einer Seite geöffnet wird.

Das erste mir einfallende Beispiel, wäre ein PayPal-Link, Welcher den Nutzer auf eine Spenden-, bzw. Überweisungsseite leiten könnte.

Man kennt diese Vorgehensweise durchaus von bekannten Programmen, Welche damit dann z. B. auf Paypal verweisen.

Dazu klickt man dann wie im folgenden Bild auf einen programminternen Link und im nächsten Schritt öffnet sich der Browser:

Code – VB.NET Webseite öffnen

Um in VB.NET eine Webseite zu öffnen, können wir natürlich auf verschiedene Steuerelemente, oder/und Ereignisse zurückgreifen.

Sei es ein PayPal-Spendenbutton, oder wie oben gezeigt ein LinkLabel, oder z. B. beim Öffnen eines Dialoges.

Es gehört meiner Meinung nach zur guten Manier, dem Nutzer zu erklären, dass sich dort jetzt sein Browser öffnet.

Ansonsten wäre das meiner Meinung nach eine schlechte User-Experience, wenn sich halt plötzlich der Browser öffnet.

Damit wir final eine Seite öffnen können, brauchen wir für unser Beispiel die Start-Methode aus der Process-Klasse

Process.Start("https://google.de")

Process.Start("https://google.de")

Das delegiert die Ausführung praktisch ans System und das System schaut: „Okay, wie kann ich das öffnen?“.

Da für dieses Schema im Hintergrund zu aller Wahrscheinlichkeit ein Browser hinterlegt ist, meldet sich der Standardbrowser.

Anschließend wird der Browser die Anfrage nach seinem Ermessen und mit eventuellen Parametern verarbeiten.

Ein analog angelehnten Beispiel sehen wir im nächsten Abschnitt, wo wir den Browser dann gesondert angeben.

Browser explizit angeben

Wer einen konkreten Browser übergeben möchte, statt den Standardbrowser zu nutzen, kann dies häufig einfach tun.

Viele gängige Programme können mit „Dingern“ namens Parametern gestartet/ausgeführt werden.

Eventuell ist Dir der Begriff Parameter ja bereits aus der Programmierung bekannt (ich denke mal :P).

Es sind letztendlich zusätzliche – ja wie sag ich lol – gewisse Werte in Form von Wörtern, oder auch Buchstaben, etc.

Diese Werte werden dann als zusätzliche „Argumente“, also Zusatzinformationen an das zu startende Programm übergeben.

Damit kann das Programm diese Parameter/Argumente bei Bedarf auswerten und nach eigener Logik verarbeiten.

Ein Beispiel für den Microsoft Edge Browser sieht z. B. wie folgt aus:

Process.Start("C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe", "https://google.de")

Es reicht also, der „Process.Start„-Methode den jeweiligen Pfad zum Browser als erstes Argument und die gewünschte Adresse als zweiten Parameter, sprich als Start-Argument zu übergeben.

Fehler abfangen

Natürlich kann es auch hier vorkommen, dass Fehler auftauchen, daher sollte man auch hier ggf. auf eine mögliche Fehlerbehandlung zurückgreifen.

Dafür verwenden wir wie gewohnt die „Try-Catch“-Anweisung und fangen den Fehler in diesem Fall global ab.

In diesem Fall reicht dies denke ich so aus, obwohl man vermutlich noch tiefer graben könnte, Welche exakten Fehler auftreten können.

Dazu kann man natürlich einen Blick auf die jeweilige Seite der Microsoft-Dokumentation zur „Process.Start“-Methode werfen.

Dann würde man ggf. eine saubere Trennung zwischen den einzelnen Fehlern erarbeiten können, um separat reagieren zu können.

Private Sub btnCatchPathError_Click(sender As Object, e As EventArgs) Handles btnCatchPathError.Click
    Dim path = "C:\Program Files\Google\Chrome\Applicatissson\chrome.exe"
    Try
        Process.Start(path, "https://paypal.de")
    Catch ex As Exception
        MessageBox.Show($"Error opening the target path: {path}")
    End Try
End Sub

.NET Core Problem lösen

Wenn man den gezeigten Code auf einer .NET Core Plattform-App verwendet, wird man eventuell auf einen Fehler stoßen.

Ich selbst bin natürlich auch beim Schreiben dieses Beitrags prompt auf diesen Fehler gestoßen – seufz.

Daher dachte ich mir: „Eeyup, das nimmst du direkt mit in den Beitrag rein ;)“.

Um diesen Fehler, bzw. dieses Problem zu vermeiden muss man eine neue Instanz der ProcessStartInfo-Klasse erstellen und konfigurieren.

Die UseShellExecute-Eigenschaft muss hierbei explizit auf True gestellt werden, damit man den Fehler vermeidet.

Hier drunter findest Du einmal das Beispiel mit einer URL und noch ein Beispiel mit der Angabe eines Browsers und URL.

    Private Sub btnOpenCoreSafe_Click(sender As Object, e As EventArgs) Handles btnOpenCoreSafe.Click
        'Dim processStartInfo = New ProcessStartInfo()
        'With processStartInfo
        '    .FileName = "https://paypal.de"
        '    .UseShellExecute = True
        'End With
        'Process.Start(processStartInfo)

        Dim processStartInfo = New ProcessStartInfo()
        With processStartInfo
            .FileName = "C:\Program Files\Google\Chrome\Application\chrome.exe"
            .Arguments = "https://paypal.de"
            .UseShellExecute = True
        End With
        Process.Start(processStartInfo)
    End Sub

Kompletter Code – VB.NET Webseite öffnen

Obwohl sich der Code in diesem Beispiel wohl bescheiden hält, werde ich mich trotzdem mal an meine Routine halten.

Daher findest Du wie in fast jedem Beitrag, den Code hier am Ende in kompletter Form:

Public Class Form1

    Private Sub llblOpenPayPalWithChrome_LinkClicked(sender As Object, e As LinkLabelLinkClickedEventArgs) Handles llblOpenPayPalWithChrome.LinkClicked
        Process.Start("C:\Program Files\Google\Chrome\Application\chrome.exe", "https://paypal.de")
    End Sub

    Private Sub btnOpenGoogleWithEdge_Click(sender As Object, e As EventArgs) Handles btnOpenGoogleWithEdge.Click
        Process.Start("C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe", "https://paypal.de")
    End Sub

    Private Sub btnOpenYouTubeWithDefaultBrowser_Click(sender As Object, e As EventArgs) Handles btnOpenYouTubeWithDefaultBrowser.Click
        Process.Start("https://youtube.de")
    End Sub

    Private Sub btnCatchPathError_Click(sender As Object, e As EventArgs) Handles btnCatchPathError.Click
        Dim path = "C:\Program Files\Google\Chrome\Applicatissson\chrome.exe"
        Try
            Process.Start(path, "https://paypal.de")
        Catch ex As Exception
            MessageBox.Show($"Error opening the target path: {path}")
        End Try
    End Sub

    Private Sub btnOpenCoreSafe_Click(sender As Object, e As EventArgs) Handles btnOpenCoreSafe.Click
        'Dim processStartInfo = New ProcessStartInfo()
        'With processStartInfo
        '    .FileName = "https://paypal.de"
        '    .UseShellExecute = True
        'End With
        'Process.Start(processStartInfo)

        Dim processStartInfo = New ProcessStartInfo()
        With processStartInfo
            .FileName = "C:\Program Files\Google\Chrome\Application\chrome.exe"
            .Arguments = "https://paypal.de"
            .UseShellExecute = True
        End With
        Process.Start(processStartInfo)
    End Sub
End Class

Downloads

Weiterführende Links

• VB.NET Webbrowser Control
• VB.NET Get Element by Class
• VB NET Formular automatisch ausfüllen (Winforms)

Der Beitrag VB.NET Webseite öffnen erschien zuerst auf Robert Skibbe.