IoT-System: Überarbeitung Datentypen

Hallo zusammen,

da ich aktuell ein wenig Zeit für mich zur Verfügung habe, ist es mir möglich mein IoT-System zu überarbeiten und auszubauen. Dafür habe ich mir überlegt, das Gesamtkonzept umzustellen, worauf ich jedoch heute noch nicht eingehen möchte. Bevor ich mit der Umstrukturierung beginnen kann, möchte ich noch ein paar Altlasten loswerden, welche ich bei der ersten Programmierung des Systems erzeugt habe. Auf eine dieser Lasten möchte ich heute eingehen.

Enumerationen

Als eines der grundlegendsten Elemente in der Programmierung des gesamten Systems existiert die Enumeration "IoTValueType". Eine Enumeration ist - einfach gesagt - ein Datentyp, welcher nur definierte Werte annehmen kann. Ein gutes Beispiel dafür ist ein Wochentag. Eine Enumeration vom Typ "Wochentag" kann logisch nur die Werte "Montag", "Dienstag", ... "Sonntag" annehmen. (mehr) Im Hintergrund kümmert sich dann der Compiler darum, dass jedem Enumerationswert ein passender Ganzzahlwert  zugeordnet wird. Diese Zuordnung kann auch per Hand durchgeführt werden.

Enumerationen können auch dafür genutzt werden, um mehrere der definierten Werte auszuwählen. Um beim gleichen Beispiel zu bleiben, könnte mit Hilfe der Enumeration "Wochentag" eine Auswahl erstellt werden, an welchen Tagen beispielsweise ein Wecker klingeln soll. Dafür muss die Enumeration mit dem "Flags-Attribut" markiert werden. Im Normalfall wird jedem Enumerationswert eine Ganzzahl zugeordnet:

(Montag = 0, Dienstag = 1, Mittwoch = 2, Donnerstag = 3, Freitag = 4, ...)

Mit dem Flags-Attribut wird jedem Wert ein Bit zugeordnet, wodurch sie praktisch Werte der Zweierpotenzreihe annehmen:

(Montag = 1, Dienstag = 2, Mittwoch = 4, Donnerstag = 8, Freitag = 16, ...)

Dadurch ist es nun möglich, Kombinationen zu bilden. Beispielsweise entspricht die Auswahl "Dienstag und Mittwoch" gleich der Zahl 6. Ohne das Flags-Attribut ergibt dieselbe Kombination die Zahl 3, welcher bereits "Donnerstag" zugeordnet ist. Es kann daher nicht unterschieden werden, ob bei einer 3 "Donnerstag" oder "Dienstag und Mittwoch" gemeint ist.

Ich habe nun bisher eine solche Enumeration verwendet, um die möglichen Datentypen im System zu definieren. Dadurch ist es nicht nur möglich gewesen, den genauen Datentyp eines Elements festzulegen, sondern mit Hilfe des Flags-Attributes auch eine Auswahl an Typen anzugeben, welche von einem Element unterstüzt werden. Dies habe ich insbesondere bei der Erstellung der Logikstrukturen verwendet, wie ich in einem früheren Post beschrieben habe.

IoTValueType-Enumeration

Die Verwendung einer Enumeration an dieser Stelle hat jedoch den Nachteil, dass die Auswahl an Datentypen auf die angegebenen Typen begrenzt ist. Eine Erweiterung ist daher nur möglich, indem neue Typen der Enumeration hinzugefügt werden. Ich habe zwar auch einen Datentyp "Objekt" hinzugefügt, welcher einen beliebigen Datentyp beschreibt, dies führt jedoch dazu, dass Elemente mit verschiedenen Objekt-Datentypen verknüpft werden können. Ein weiterer negativer Punkt ist, dass keine Arrays o.Ä. existieren. Arrays können zwar auch über den Objekt-Datentyp übergeben werden, aber das führt wieder zu dem eben genannten Verhalten.

DataType - Klasse

Um die aufgezeigten Probleme zu lösen, habe ich beschlossen die Enumeration "IoTValueType" zu ersetzen. Dafür habe ich mir zunächst überlegt, welche Arten von Datentypen es gibt und wie diese zu differenzieren sind. Grundsätzlich resultieren daraus drei Arten: Ein Grunddatentyp, welcher einfache Werte wie Ganzzahlen, Strings, etc. darstellt, ein Arraydatentyp, welcher eine Auflistung von Werten eines Datentyps darstellt und ein komplexer Datentyp, welcher eine Zusammenstellung verschiedener Datentypen darstellt. Die genannten Datentypen habe ich nun durch Klassen beschrieben, welche alle eine gemeinsame "DataType"-Basisklasse verwenden.

Datenstruktur "DataType"

Neben den im Bild dargestellten Feldern besitzt die DataType-Basisklasse noch weitere Felder und Methoden, um beispielsweise einem Datentyp Methoden zum Serialisieren und Deserialisieren zuzuordnen.

MultiDataType

Die Verwendung der genannten DataType-Klasse hat aber nun den Nachteil, dass jeweils nur exakt ein Datentyp verwendet werden kann. Daher habe ich zusätzlich eine Klasse MultiDataType angelegt, welche es ermöglicht mehrere mögliche Datentypen anzugeben.

using System;
using System.Collections.Generic;
using System.Linq;
using HomeAutomationServerExtensionInterface;
 
namespace LogicStructureEditor
{
 public class MultiDataType
 {

using System;
using System.Collections.Generic;
using System.Linq;
using HomeAutomationServerExtensionInterface;
 
namespace LogicStructureEditor
{
 public class MultiDataType
 {
  private enum WorkMode
  {
   All,
   TypesByList,
   AllExceptList,
   None
  }
  private readonly WorkMode workMode = WorkMode.All;
  private readonly List<DataType> types;
 
  private bool AcceptAll { get { return workMode == WorkMode.All; } }
  private bool AcceptNone { get { return workMode == WorkMode.None; } }
 
  public MultiDataType(IEnumerable<DataType> types)
  {
   if (types == null || !types.Any())
   {
    workMode = WorkMode.None;
   } else { 
    this.types = new List<DataType>(types);
    workMode = WorkMode.TypesByList;
   }
  }
  public MultiDataType(DataType type)
  {
   if (type == null)
   {
    workMode = WorkMode.None;
   } else
   {
    types = new List<DataType>() { type };
    workMode = WorkMode.TypesByList;
   }
  }
 
  //Private constructor for operators
  private MultiDataType(WorkMode mode, IEnumerable<DataType> types)
  {
   switch (mode)
   {
    case WorkMode.All:
     break;
    case WorkMode.None:
     break;
    case WorkMode.AllExceptList:
     if (types == null || !types.Any())
     {
      workMode = WorkMode.All;
      return;
     }
     this.types = new List<DataType>(types);
     break;
    case WorkMode.TypesByList:
     if (types == null || !types.Any())
     {
      workMode = WorkMode.None;
      return;
     }
     this.types = new List<DataType>(types);
     break;
   }
   workMode = mode;
  }
  static MultiDataType()
  {
   AllTypes = new MultiDataType(WorkMode.All, null);
   None = new MultiDataType(WorkMode.None, null);
  }
  public static readonly MultiDataType AllTypes = null;
  public static readonly MultiDataType None = null;
 
  public DataType GetSingleDataType()
  {
   if(workMode == WorkMode.All)
   {
    throw new Exception("Unable to get DataType from MultiDataType with all elements.");
   }
   if (workMode == WorkMode.None)
   {
    throw new Exception("Unable to get DataType from MultiDataType with zero elements.");
   }
   if(workMode == WorkMode.AllExceptList)
   {
    throw new Exception("Unable to get DataType from MultiDataType with more than one element.");
   }
   if (types.Count == 0)
   {
    throw new Exception("Unable to get DataType from MultiDataType with zero elements.");
   }
   if (types.Count != 1)
   {
    throw new Exception("Unable to get DataType from MultiDataType with more than one element.");
   }
   return types[0];
  }
 
  public bool Any()
  {
   switch (workMode)
   {
    case WorkMode.None:
     return false;
    case WorkMode.All:
     return true;
    case WorkMode.TypesByList:
     return true;
    case WorkMode.AllExceptList:
     return true;
   }
   throw new Exception("Invalid WorkMode: " + workMode.ToString());
  }
  public bool SingleType()
  {
   switch (workMode)
   {
    case WorkMode.None:
     return false;
    case WorkMode.All:
     return false;
    case WorkMode.TypesByList:
     return types.Count == 1;
    case WorkMode.AllExceptList:
     return false;
   }
   throw new Exception("Invalid WorkMode: " + workMode.ToString());
  }
 
  public override int GetHashCode()
  {
   if(workMode == WorkMode.All)
   {
    return 12345678;
   }
   if(workMode == WorkMode.None)
   {
    return 87654321;
   }
   int hash;
   if (workMode == WorkMode.AllExceptList)
   {
    hash = 19 + types.Count;
   } else
   {
    hash = 29 + types.Count;
   }
   foreach (DataType t in types)
   {
    hash = hash * 31 + t.GetHashCode();
   }
   return hash;
  }
  public override bool Equals(object obj)
  {
   if (obj.GetType() != typeof(MultiDataType)) { return false; }
   return this == (MultiDataType)obj;
  }
 
  public static bool operator ==(MultiDataType obj1, MultiDataType obj2)
  {
   //Check if both use the same workmode. Otherwise they are different.
   if (obj1.workMode != obj2.workMode) { return false; }
   //If one (=both) accepts all or none elements, they are equal.
   if (obj1.AcceptAll || obj1.AcceptNone) { return true; }
   //The are on the same workmode. Their typelist should contain the same values.
   if (obj1.types.Count != obj2.types.Count) { return false; }
   return obj1.types.Except(obj2.types).Any() == false;
  }
  public static bool operator !=(MultiDataType obj1, MultiDataType obj2)
  {
   //Check if both use the same workmode. Otherwise they are different.
   if (obj1.workMode != obj2.workMode) { return true; }
   //If one (=both) accepts all or none elements, they are equal.
   if (obj1.AcceptAll || obj2.AcceptNone) { return false; }
   //The are on the same workmode. Their typelist should contain the same values.
   if (obj1.types.Count != obj2.types.Count) { return true; }
   return obj1.types.Except(obj2.types).Any();
  }
 
  public static bool operator ==(MultiDataType obj1, DataType obj2)
  {
   if(obj1.workMode != WorkMode.TypesByList) { return false; }
   if (obj1.types.Count != 1) { return false; }
   return obj1.types[0] == obj2;
  }
  public static bool operator !=(MultiDataType obj1, DataType obj2)
  {
   if (obj1.workMode != WorkMode.TypesByList) { return true; }
   if (obj1.types.Count != 1) { return true; }
   return obj1.types[0] != obj2;
  }
 
  public static MultiDataType operator &(MultiDataType obj1, MultiDataType obj2)
  {
   //If one of them accepts all, the second one is the restriction
   if (obj1.AcceptAll) { return obj2; }
   if (obj2.AcceptAll) { return obj1; }
   //If one of them accepts none, then it is the restriction
   if (obj1.AcceptNone) { return obj1; }
   if (obj2.AcceptNone) { return obj2; }
   //Check if their modes are equal
   if (obj1.workMode == obj2.workMode)
   {
    if (obj1.workMode == WorkMode.TypesByList)
    {
     //Both are working normal. Return the ones, which are in both lists
     return new MultiDataType(WorkMode.TypesByList, obj1.types.Where(X => obj2.types.Contains(X)));
    } else
    {
     //Both are working in Except-Mode. Return the ones, which are in none of both lists
     return new MultiDataType(WorkMode.AllExceptList, obj1.types.Union(obj2.types));
    }
   } else
   {
    //The elements ere different.
    if (obj1.workMode == WorkMode.TypesByList)
    {
     //Obj1 is working normal and obj2 is working in Except-mode. Return the ones, which are in the first one, but not in the second one.
     return new MultiDataType(WorkMode.TypesByList, obj1.types.Where(X => (obj2.types.Contains(X) == false)));
    } else
    {
     //Obj1 is working in Except-mode and obj2 is working normal. Return the ones, which are not in the first one, but in the second one.
     return new MultiDataType(WorkMode.TypesByList, obj2.types.Where(X => (obj1.types.Contains(X) == false)));
    }
   }
  }
  public static MultiDataType operator |(MultiDataType obj1, MultiDataType obj2)
  {
   //If one of them accepts all, the result will accept all
   if (obj1.AcceptAll) { return obj1; }
   if (obj2.AcceptAll) { return obj2; }
   //if one of them accepts none, then the result will be the other object
   if (obj1.AcceptNone) { return obj2; }
   if (obj2.AcceptNone) { return obj1; }
   //Check if their modes are equal
   if (obj1.workMode == obj2.workMode)
   {
    if (obj1.workMode == WorkMode.TypesByList)
    {
     //Both are working normal. Return the elements from both lists.
     return new MultiDataType(obj1.types.Union(obj2.types));
    } else
    {
     //Both are working in Except-Mode.
     return new MultiDataType(WorkMode.AllExceptList, obj1.types.Where(X => obj2.types.Contains(X)));
    }
   } else
   {
    if (obj1.workMode == WorkMode.TypesByList)
    {
     //Obj1 is working normal and obj2 is working in Except-mode.
     return new MultiDataType(WorkMode.AllExceptList, obj2.types.Where(X => (obj1.types.Contains(X) == false)));
    } else
    {
     return new MultiDataType(WorkMode.AllExceptList, obj1.types.Where(X => (obj2.types.Contains(X) == false)));
    }
   }
   
  }
  public static MultiDataType operator &(MultiDataType obj1, DataType obj2)
  {
   switch (obj1.workMode)
   {
    case WorkMode.All:
     return new MultiDataType(obj2);
    case WorkMode.None:
     return None;
    case WorkMode.TypesByList:
     if (obj1.types.Contains(obj2))
     {
      return new MultiDataType(obj2);
     } else
     {
      return None;
     }
    case WorkMode.AllExceptList:
     if (obj1.types.Contains(obj2))
     {
      return obj1;
     } else
     {
      List<DataType> types = new List<DataType>(obj1.types);
      types.Add(obj2);
      return new MultiDataType(WorkMode.AllExceptList, types);
     }
   }
   throw new Exception("Invalid WorkMode: " + obj1.workMode.ToString());
  }
  public static MultiDataType operator |(MultiDataType obj1, DataType obj2)
  {
   switch (obj1.workMode)
   {
    case WorkMode.All:
     return AllTypes;
    case WorkMode.None:
     return new MultiDataType(obj2);
    case WorkMode.TypesByList:
     List<DataType> types = new List<DataType>(obj1.types);
     types.Add(obj2);
     return new MultiDataType(WorkMode.TypesByList, types);
    case WorkMode.AllExceptList:
     return new MultiDataType(obj1.types.Where(X => X != obj2));
   }
   throw new Exception("Invalid WorkMode: " + obj1.workMode.ToString());
  }
  
  public static MultiDataType operator ~(MultiDataType obj)
  {
   switch (obj.workMode)
   {
    case WorkMode.All:
     return None;
    case WorkMode.None:
     return AllTypes;
    case WorkMode.TypesByList:
     return new MultiDataType(WorkMode.AllExceptList, obj.types);
    case WorkMode.AllExceptList:
     return new MultiDataType(WorkMode.TypesByList, obj.types);
   }
   throw new Exception("Invalid WorkMode: " + obj.workMode.ToString());
  }
 
 }
}

Das Prinzip des MultiDataType besteht darin, dass es zunächst vier Zustände besitzt. Diese sind "Alle", "Keine", "Alle außer" und "Keine außer". Bei der Nutzung einer der letzten beiden Zustände wird außerdem eine Liste verwendet, welche die Datentypen enthält, welche zulässig oder eben nicht zulässig sind.

Zudem definiert die Klasse Operatoren zum Vergleich und die Bitoperatoren OR, AND und die Bitweise-Negation. Diese werden verwendet, um das Verhalten der Enumeration des alten IoTValueType weiterverwenden zu können. Dadurch kann ein Großteil des geschriebenen Quellcodes weiterverwendet werden. Trotzdem war es nötig, große Teile des Quellcodes zu überarbeiten. Die Überarbeitung ist aber nun abgeschlossen und mein System läuft mit der überarbeiteten Variante.

Im nächsten Schritt werde ich die Anfangs erwähnte Umstrukturierung des Systems angehen. Dazu werde ich mich hier äußern, wenn ich dies abgeschlossen habe.

Bis dahin,
Markus