Best Practice für die Strukturierung meines Typs

Question

Ich habe Protokolle, die ich versuche, ein Dienstprogramm zu analysieren, zu analysieren.

Diese Protokolle sind als CSVs strukturiert, aber die Anzahl der Abschnitte (Spalten) variiert je nach "Transaktionsart". Es gibt ungefähr 50 verschiedene Möglichkeiten des "Transaktionstyps", so dass eine Klasse für jeden nicht machbar ist.

Beispiel Log-Einträge:

2016-08-02 10:36:30.578 (Machine: 00124) Received: 1120228,T,2016-08-02 10:36:30,5,18441,209719,1,20 
2016-08-02 10:36:30.594 (Machine: 00124) Sent: 1120228,T,2016-08-02 10:36:30,0,,0,18441,DhfMAAfjhsb6CiW55999999TbNakCC3Fc8jaZ 

Jeder Received hat eine passende Sent. Die Werte und die dargestellten Parameter unterscheiden sich um Received und Sent sowie den Transaktionstyp.

Die Idee und aktuelle Implementierung ist wie folgt.

1. Lastleitung und Split auf Komma (,)
2. ermitteln „Transaktionsart“
3. laden zugeordnet Schema aus einem XML und gewinnen die Parameter der Wert für jeden darstellt.
4. Shop in einer Art je nachdem, ob es Received oder Sent

Aktuelle Umsetzung:

public class Message : IMessage 
     { 
      private List<Received> _receivedMessage; 
      private List<Sent> _sentMessage; 

      public Message() 
      { 
       ReceivedMessage = new List<Received>(); 
       SentMessage = new List<Sent>(); 
      } 

      public Message(
        string messageID, 
        List<Received> receivedMessage, 
        List<Sent> sentMessage, 
        string storedProcedure, 
        string transShortName) 
      { 
       MessageID = messageID; 
       ReceivedMessage = receivedMessage; 
       SentMessage = sentMessage; 
       StoredProcedure = storedProcedure; 
       TransShortName = transShortName; 
      } 

      public string MessageID { get; set; } 

      public List<Received> ReceivedMessage 
      { 
       get { return new List<Received>(_receivedMessage.OrderBy(_ => _.Position)); } 
       set { _receivedMessage = value; } 
      } 

      public List<Sent> SentMessage 
      { 
       get { return new List<Sent>(_sentMessage.OrderBy(_ => _.Position)); } 
       set { _sentMessage = value; } 
      } 

      public string StoredProcedure { get; set; } 

      public string TransShortName { get; set; } 

      public class Sent : ISent 
      { 
       public string MessageID { get; set; } 

       public dynamic Value { get; set; } 

       public string Parameter { get; set; } 

       public string Position { get; set; } 
      } 

      public class Received : IReceived 
      { 
       public string MessageID { get; set; } 

       public dynamic Value { get; set; } 

       public string Error { get; set; } 

       public string Parameter { get; set; } 

       public string Position { get; set; } 

       public string Regex { get; set; } 

       //public string TransShortName { get; set; } 
      } 
     } 

isent Schnittstelle:

public interface ISent 
    { 
     string Parameter { get; set; } 
     string Position { get; set; } 
     dynamic Value { get; set; } 
    } 

IReceived Schnittstelle:

public interface IReceived 
    { 
     string Error { get; set; } 
     string Parameter { get; set; } 
     string Position { get; set; } 
     string Regex { get; set; } 
     //string TransShortName { get; set; } 
    } 

Idee, Best Practices, alles, sind gnädig willkommen!

Answer 1

Wenn Sie keine Klasse für jeden Typ haben möchten, würde ich vorschlagen, die allgemeinen Eigenschaften als reguläre Eigenschaften und die dynamischen Eigenschaften als Schlüssel/Wert-Paare in einem Wörterbuch zu haben. Irgendwann in deinem Code wirst du wissen müssen, welche Eigenschaften in einem Typ sind.

Wenn Sie ein Schema für alle 50 Typen haben, können Sie mithilfe des XSD-Befehlszeilentools die C# -Klassen aus dem Schema generieren. Die Benennungskonventionen könnten jedoch ein bisschen verrückt sein :).