JSON Parsen

[franktron]

Ich habe ein Problem mit C# MVC, ich muss ein JSON Parsen der nicht immer gleich ist.

1. Zustand "[[\"Bezeichnung\",\"=\",\"2K-Gelcoat-PUR-Steodur-3kg\"]]"
2. Zustand "[[[\"Bezeichnung\",\"=\",\"2K-Gelcoat-PUR-Steodur-3kg\"]],\"and\",[[\"charge\",\"=\",\"11\"]]]"

WIe kann ich das machen für Zustand 1 habe ich volgenden Code

Code:

JavaScriptSerializer serializer = new JavaScriptSerializer();
            List<string[]> filterItems = serializer.Deserialize<List<string[]>>(filter);

            string buffer = "";

            foreach (string[] filterItem in filterItems)
            {
               buffer = buffer + filterItem[0] + " " + filterItem[1] + " " + filterItem[2];
               //list = FilterItems<YourItemType>(list, filterItem[0], filterItem[2]);
            }

[Sir Rufo]

Sei doch so lieb und zeige uns den puren JSON-Code (eingebettet in die CODE-Tags). Bei diesem String aus dem Debugger mit den Escape-Zeichen sieht man ja den Wald vor lauter Bäumen nicht.

Ich wette, dann wird dich auch schon die Lösung anspringen :stupid:

[franktron]

Sorry habs einfach aus dem Debug rasukopiert


1. [["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]
2. [[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]

[Sir Rufo]

1. Variante
   
   Code:

   [
      [
         "Bezeichnung",
         "=",
         "Angussstutzen-Rev/B-PPTV30"
      ]
   ]

2. Variante
   
   Code:

   [
      [
         [
            "Bezeichnung",
            "=",
            "Angussstutzen-Rev/B-PPTV30"
         ]
      ],
      "and",
      [
         [
            "charge",
            "=",
            "11"
         ]
      ]
   ]

Schauen wir uns an, was wir da haben (wir fangen von aussen an):

• Hat das äußere Array einen Eintrag, dann haben wir die Variante 1 vor uns
• Hat das äußere Array drei Einträge, dann haben wir die Variante 2 vor uns, wobei das Item 0 und Item 2 wie die Variante 1 behandelt werden kann

[himitsu]

Es ist eigentlich immer nur eine Variante. (im aktuellen Beispiel)

Delphi-Quellcode:

[WertA, Operator, WertB]

Code:

Auswertgung:
[
   "Bezeichnung",        Spalte
   "=",                  Vergleichsoperator
   "Angussstutzen..."    Wert
]

Verknüpfung
[
   [ VergleichA ],       GruppeA
   "and",                Operator
   [ VergleichB ]        GruppeB
]

interessant wären jetzt mehrere Verknüpfungen ... eventuell so, oder immer nur in 2er-Gruppen
[
   [ VergleichA ],       GruppeA
   "and",                Operator
   [ VergleichB ]        GruppeB
   "and",                Operator
   [ VergleichC ]        GruppeC
]

[
   [ VergleichA ],       GruppeA
   "and",                Operator
   [
      [ VergleichB ]     GruppeB.A
      "and",             Operator
      [ VergleichC ]     GruppeB.B
   ]
]

[Sir Rufo]

Wenn ich die eckigen Klammern zähle, dann sehe ich das etwas anders

[himitsu]

Lege zwei "Auswertgung" in ein "Verknüpfung" rein und schon kommt das doch mit den Klammern doch hin?

[Sir Rufo]

Zitat:

Zitat von himitsu (Beitrag 1333185)

Lege zwei "Auswertgung" in ein "Verknüpfung" rein und schon kommt das doch mit den Klammern doch hin?

Es gibt aber auch den Fall, wo es nur einen Vergleich gibt. Diesen Fall muss man speziell behandeln, alle anderen (mehrere Vergleiche verknüpft mit einem Operator) folgen durchaus dem, was du gezeigt hast.

Die Frage dreht sich hier aber ganz speziell um die Erkennung dieser beiden Fälle

[Sir Rufo]

Mal eben so heruntergetippt ...

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.Json,
  System.SysUtils;

function IsEven( const Value: Integer ): Boolean;
begin
  Result := Value mod 2 = 0;
end;

function ParseSingleExpression( AJsonArray: TJsonArray ): string;
var
  lInner    : TJsonArray;
  lFieldName: string;
  lOperator : string;
  lValue    : string;
begin
  if AJsonArray.Count <> 1
  then
    raise EArgumentException.Create( 'single item in array expected' );

  if not( AJsonArray.Items[ 0 ] is TJsonArray )
  then
    raise EArgumentException.Create( 'array expected' );

  lInner := AJsonArray.Items[ 0 ] as TJsonArray;

  if lInner.Count <> 3
  then
    raise EArgumentException.Create( 'three items expected' );

  if not( lInner.Items[ 0 ] is TJSONString )
  then
    raise EArgumentException.Create( 'string expected' );
  lFieldName := lInner.Items[ 0 ].Value;

  if not( lInner.Items[ 1 ] is TJSONString )
  then
    raise EArgumentException.Create( 'string expected' );
  lOperator := lInner.Items[ 1 ].Value;

  if lInner.Items[ 2 ] is TJSONString
  then
    lValue := QuotedStr( lInner.Items[ 2 ].Value )
  else
    lValue := lInner.Items[ 2 ].Value;

  Result := string.Format( '(%s %s %s)', [ lFieldName, lOperator, lValue ] );
end;

function ParseJsonExpression( AJsonArray: TJsonArray ): string;
overload
var
  I: Integer;
begin
  if IsEven( AJsonArray.Count )
  then
    raise EArgumentException.Create( 'odd items in array expected' );

  if AJsonArray.Count = 1
  then
    Result := ParseSingleExpression( AJsonArray )
  else
    begin
      Result := '( ';
      for I  := 0 to AJsonArray.Count - 1 do
        begin
          if I mod 2 = 0
          then
            if AJsonArray.Items[ I ] is TJsonArray
            then
              Result := Result + ParseJsonExpression( AJsonArray.Items[ I ] as TJsonArray )
            else
              raise EArgumentException.Create( 'Array expected' )
          else
            Result := Result + ' ' + AJsonArray.Items[ I ].Value + ' ';
        end;
      Result := Result + ' )';
    end;
end;

function ParseJsonExpression( AJsonStr: string ): string; overload;
var
  lValue: TJSONValue;
begin
  lValue := TJSONObject.ParseJSONValue( AJsonStr );
  try
    if lValue is TJsonArray
    then
      Result := ParseJsonExpression( lValue as TJsonArray )
    else
      raise EArgumentException.Create( 'Fehlermeldung' );
  finally
    lValue.Free;
  end;
end;

const
  Data1 = '[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]';
  Data2 = '[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]';
  Data3 = '[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]],"and",[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]]';

procedure Main;
begin
  WriteLn( Data1 );
  WriteLn( ParseJsonExpression( Data1 ) );
  WriteLn;
  WriteLn( Data2 );
  WriteLn( ParseJsonExpression( Data2 ) );
  WriteLn;
  WriteLn( Data3 );
  WriteLn( ParseJsonExpression( Data3 ) );
end;

begin
  try
    Main( );
  except
    on E: Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

und liefert

Code:

[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]
(Bezeichnung = 'Angussstutzen-Rev/B-PPTV30')

[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]
( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') )

[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]],"and",[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]]
( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') and ( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') ) )

[Sherlock]

Sorry4OT: So viel zum Thema "JSON ist sooo einfach" :D XML hat halt etwas mehr overhead, aber einfacher als JSON ist es allemal.

Sherlock