Tipp zur Implementierung auswählbarer Hardware API (static class methoden auswählbar)

Hallo,

bin in C# noch relativer Neuling und komme eher aus der hardwarenahen Programmierung.

Ich würde gerne in einem Projekt die Hardware auswählbar machen. Aktuell hab ich nur eine (PEAK-CAN USB) dafür gibts eine XCP-API die mir eine statische Klasse bereitstellt um die Methoden auszufürhten. Ich würde nun gerne eine art Klasse als Schnittstelle nehmen die je nach initialer auswahl die Methoden der PEAK-CAN Hardware aufruft oder einer zukünftig implementierten Hardware über Serial-COM etc.

Ich hab schon Schnittstelle genannt aber komm in meinen Gedanken auf keinen grünen zweig wies funktionieren soll.

Folgender Code ist nur zur Veranschaulichung gedacht, wie ich es in etwa gerne hätte. Funktioniert natürlich nicht!!

Vielen Dank schon mal für Antworten und Anregungen!

class GUI
{
    HardwareInterface hrdwr;
    GUI(int iHardwareEnum)
    {
        hrdwr = new HardwareInterface(iHardwareEnum);
    }
    void HardwareConnect()
    {
        hrdwr.Connect();
    }
}

public class HardwareInterface
{
    public HardwareInterface(int iHardwareSelect)
    {
        //if iHardwareSelect == Peak-CAN implement XCPApiPeak else == Serial-COM implement Serial-COM API
    }

    public void Connect()
    {
        
    }
}

public static class XCPApiPeak
{
    public static void Connect(void);

}

public static class SerialCOM
{
    public static void Connect(void);
}

Im Endeffekt alles mit Basics der Objektorientierten Programmierung umzusetzen.
Dazu brauchst Du nur

• Ein gemeinsames Interface
• Spezifische Implementierungen der Hardware
• Eine Factory die eine Instanz je nach Hardware zurück gibt

namespace MyNamespace
{
    public interface IMyHardwareInterface
    {
        void Connect();
    }

    public class XCPApiPeakInterface : IMyHardwareInterface
    {
        public void Connect() => throw new System.NotImplementedException();
    }

    public class SerialCOM : IMyHardwareInterface
    {
        public void Connect() => throw new System.NotImplementedException();
    }

    public enum MyHardwareInterfaceType
    {
        XCPApi,
        SerialCOM
    }

    public class MyHardwareInterfaceFactory
    {
        public IMyHardwareInterface GetInstance(MyHardwareInterfaceType type) // oder enum oder whatever
        {
            switch (type)
            {
                case MyHardwareInterfaceType.XCPApi:
                    return new XCPApiPeakInterface();
                case MyHardwareInterfaceType.SerialCOM:
                    return new SerialCOM();
            }

            throw new ArgumentOutOfRangeException($"Unknown type {type}");
        }
    }
    public class MyApp
    {
        public void Sample(MyHardwareInterfaceFactory factory)
        {
            IMyHardwareInterface instance = factory.GetInstance(MyHardwareInterfaceType.XCPApi);

            instance.Connect();
        }
    }
}

Aber im Endeffekt kommen bei solch einer Anforderung mehrere potentiellen Pattern in Frage.
Kannst Dich ja bisschen selbst schlau machen: https://www.dofactory.com/net/design-patterns

Vielen Dank! Funktioniert!
Super Link mit den Design Patterns, kannte ich noch nicht!