Delphi zu c# Frage

Question

Ich habe ein Delphi-Programm, das ich in c# konvertieren muss. Ich habe die meisten der Konvertierung getan, aber lief in ein paar Herausforderungen mit VarArrayCreate.

was ich habe, ist dies: Zeile := VarArrayCreate([0, 1], varVariant);

Ich kann nicht scheinen, um herauszufinden, eine Konvertierung oder Ersatz für die VarArrayCreate. Ich weiß, dass das Objekt in c# für Variant Ersatz verwendet werden kann, aber die oben hat mich stecken.

jede Hilfe wäre großartig.

Ich habe den folgenden Delphi-Code in die Prozedur "TForm1.Button3Click(Sender: TObject); procedure" eingefügt:

unit Unit1;

(*------------------------------------------------------------------------------
DX Atlas Automation demo #2 (early binding)

Make sure that DX Atlas is installed.

Requires DxAtlas_TLB. You can either generate this file in Delphi
(Project -> Import Type Library -> DxAtlas) or use the one included
with this demo.

http://www.dxatlas.com
------------------------------------------------------------------------------*)

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  OleServer, StdCtrls, DxAtlas_TLB, ActiveX, AxCtrls, ExtCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    CheckBox1: TCheckBox;
    Button3: TButton;
    Button4: TButton;
    Button5: TButton;
    Button6: TButton;
    procedure FormShow(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
    procedure Button5Click(Sender: TObject);
    procedure Button6Click(Sender: TObject);
  private
    { Private declarations }
  public
    Atlas: IAtlas;
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

//------------------------------------------------------------------------------
//                             Start DX Atlas
//------------------------------------------------------------------------------
procedure TForm1.FormCreate(Sender: TObject);
begin
  //connect to Dx Atlas on program startup
  try
    Atlas := CoAtlas.Create;
  except on E: Exception do
    begin
    ShowMessage('Cannot connect to DX Atlas: ' + E.Message);
    Application.Terminate;
    end;
  end;
end;

procedure TForm1.FormShow(Sender: TObject);
var
  WorkArea: TRect;
begin
  //get Desktop work area dimensions
  SystemParametersInfo(SPI_GETWORKAREA, 0, @WorkArea, 0);

  //form placement

  Top := WorkArea.Top;
  Left := WorkArea.Left;
  Height := WorkArea.Bottom - WorkArea.Top;

  //atlas placement

  //stop repainting
  Atlas.Map.BeginUpdate;
  //place window
  Atlas.Top := Top;
  Atlas.Left := Left + Width;
  Atlas.Width := WorkArea.Right - Left - Width;
  Atlas.Height := Height;
  //hide prefixes
  Atlas.Map.PrefixesVisible := false;
  //now allow repainting
  Atlas.Map.EndUpdate;
  //show the Atlas window
  Atlas.Visible := true;
end;

//------------------------------------------------------------------------------
//                                  Points
//------------------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
var
  Pt, Points: OleVariant;
  i: integer;
  Layer: ICustomLayer;
begin
  Randomize;

  //create Variant array for data
  Points := VarArrayCreate([0, 999], varVariant);

  //fill the array with random points

  for i:=0 to 999 do
    begin
    //each point is a variant array with 2 elements
    Pt := VarArrayCreate([0,1], varVariant);
    //point coordinates are random (decimal degrees)
    Pt[0] := Random(360) - 180; //longitude
    Pt[1] := Random(180) - 90;  //latitude
    //add point to the data array
    Points[i] := Pt;
    end;

  //show data on the map

  Atlas.Map.BeginUpdate;
  with Atlas.Map do
    try

      Projection := PRJ_RECTANGULAR;
      Dimmed := false;
      CustomLayers.Clear;
      //add new custom layer
      Layer := CustomLayers.Add(LK_POINTS);
      with Layer do
        begin
        //set layer attributes
        PenColor := clBlue;
        BrushColor := clLime;
        PointSize := 2;
        //set data
        SetData(Points);
        end;
    finally
      EndUpdate;
    end;
end;

//------------------------------------------------------------------------------
//                                  Labels
//------------------------------------------------------------------------------
procedure TForm1.Button2Click(Sender: TObject);
var
  //Lb: Variant;
  Labels: Variant;
  i: integer;
  Layer: ICustomLayer;
begin
  Randomize;

  Labels := VarArrayCreate([0, 999], varVariant);

  for i:=0 to 999 do
    begin
    //each label is a variant array of 3 Variants
    Labels[i] := VarArrayOf([Random(360) - 180,           //longitude
                            Random(180) - 90,             //latitude
                            Format(' LABEL #%d ', [i])]); //label text

    //alternate way of creating and filling the array
    {
    Lb := VarArrayCreate([0,2], varVariant);
    Lb[0] := Random(360) - 180;
    Lb[1] := Random(180) - 90;
    Lb[2] := Format(' Label #%d ', [i]);
    Labels[i] := Lb;
    }
    end;

  Atlas.Map.BeginUpdate;
  with Atlas.Map do
   try
     Projection := PRJ_RECTANGULAR;
     Dimmed := false;
     CustomLayers.Clear;
     Layer := CustomLayers.Add(LK_LABELS);
     with Layer do
       begin
       LabelsTransparent := CheckBox1.Checked;
       //label BG if not transparent
       BrushColor := clAqua;
       //font attributes

       with (Font as IFont) do
         begin
         Put_Name('Courier New');
         Put_Italic(true);
         Put_Size(9);

         //Put_Name('Small fonts');
         //Put_Size(5);
         end;

       //font color
       PenColor := clBlue;
       //data
       SetData(Labels);
       end;
   finally
     EndUpdate;
   end;
end;

//------------------------------------------------------------------------------
//                                  Lines
//------------------------------------------------------------------------------
procedure TForm1.Button3Click(Sender: TObject);
var
  Pt, Line, Meridians, Parallels: OleVariant;
  i, j: integer;
begin
  //generate meridians
  Meridians := VarArrayCreate([0, 7], varVariant);
  for i:=0 to 7 do
    begin
    Line := VarArrayCreate([0, 36], varVariant);
    for j:=0 to 36 do
      begin
      Pt := VarArrayCreate([0, 1], varVariant);
      Pt[0] := i*45 - 180;
      Pt[1] := j*5 - 90;
      Line[j] := Pt;
      end;
    Meridians[i] := Line;
    end;

  //generate parallels
  Parallels := VarArrayCreate([0, 2], varVariant);
  for i:=0 to 2 do
    begin
    Line := VarArrayCreate([0, 72], varVariant);
    for j:=0 to 72 do
      begin
      Pt := VarArrayCreate([0, 1], varVariant);
      Pt[0] := j*5 - 180;
      Pt[1] := i*45 - 45;
      Line[j] := Pt;
      end;
    Parallels[i] := Line;
    end;

  //show on the map

  Atlas.Map.BeginUpdate;
  with Atlas.Map do
   try
     Projection := PRJ_AZIMUTHAL;
     Dimmed := false;
     CenterLatitude := 43;
     CenterLongitude := -79;
     CustomLayers.Clear;

     //show meridians
     with CustomLayers.Add(LK_LINES) do
       begin
       PenColor := clBlue;
       SetData(Meridians);
       end;

     //show parallels
     with CustomLayers.Add(LK_LINES) do
       begin
       PenColor := clRed;
       SetData(Parallels);
       end;

   finally
     EndUpdate;
   end;
end;

//------------------------------------------------------------------------------
//                                  Area
//------------------------------------------------------------------------------
procedure TForm1.Button4Click(Sender: TObject);
var
  Pt, Area, Areas: OleVariant;
  i: integer;
begin
  //single area
  Areas := VarArrayCreate([0, 0], varVariant);

  //generate area data
  Area := VarArrayCreate([0, 72], varVariant);
  for i:=0 to 72 do
    begin
    Pt := VarArrayCreate([0, 1], varVariant);
    Pt[0] := -79 + 20 * cos(i*5/180*Pi);
    Pt[1] := 43 + 20 * sin(i*5/180*Pi);
    Area[i] := Pt;
    end;

  Areas[0] := Area;

  //show on the map
  Atlas.Map.BeginUpdate;
  with Atlas.Map do
   try
     Projection := PRJ_RECTANGULAR;
     Dimmed := true;
     CustomLayers.Clear;
     with CustomLayers.Add(LK_AREAS) do
       begin
       AreaBrightness := 12; //0..15, 15=max
       SetData(Areas);
       end;
   finally
     EndUpdate;
   end;
end;

//------------------------------------------------------------------------------
//                                  Glyphs
//------------------------------------------------------------------------------
procedure TForm1.Button5Click(Sender: TObject);
var
  Glyphs: Variant;
  i: integer;
  Layer: ICustomLayer;
begin
  Randomize;

  //create array of Variants
  Glyphs := VarArrayCreate([0,333], varVariant);
  //each element of the array is a variant array with 3 elements
  for i:=0 to 333 do
    Glyphs[i] := VarArrayOf([Random(360)-180, //longitude    -180..180
                             Random(180)-90,  //latitude     -90..90
                             Random(10)]);    //image index   0..9

  Atlas.Map.BeginUpdate;
  with Atlas.Map do
   try
     Projection := PRJ_RECTANGULAR;
     Dimmed := false;
     //delete all layers
     CustomLayers.Clear;
     //add layer
     Layer := CustomLayers.Add(LK_GLYPHS);
     //Glyphs.bmp is a bitmap 160x16 that contains 10 glyphs, 16x16 each
     //the color of lower left pixel (clFuchsia) is considered transparent
     //the hot spot of the glyph is at (1, 15).
     Layer.LoadGlyphsFromFile(ExtractFilePath(ParamStr(0)) + 'Glyphs.bmp', 1, 15);
     //send locations to the layer
     Layer.SetData(Glyphs);
   finally
     //now allow repainting
     EndUpdate;
   end;
end;

//------------------------------------------------------------------------------
//                            Great Circle paths
//------------------------------------------------------------------------------
procedure TForm1.Button6Click(Sender: TObject);
var
  Pt, Line, Lines: Variant;
  i, j: integer;
begin
  //generate an array of Great Circle paths

  Lines := VarArrayCreate([0, 33], varVariant);
  for i:=0 to 33 do
    begin
    //a Great Circle path is defined by its end points
    Line := VarArrayCreate([0, 1], varVariant);
    Line[0] := VarArrayOf([-79, 43 {Toronto}]);
    Line[1] := VarArrayOf([Random(360) - 180, Random(180) - 90]);
    //add path to the array
    Lines[i] := Line;
    end;

  //show paths on the map

  Atlas.Map.BeginUpdate;
  with Atlas.Map do
   try
     Projection := PRJ_RECTANGULAR;
     Dimmed := false;
     CustomLayers.Clear;
     with CustomLayers.Add(LK_LINES) do
       begin
       PenColor := clBlue;
       SetData(Lines);
       end;
   finally
     EndUpdate;
   end;

  //Note that Delphi automatically releases the variant arrays when they go out of scope.
  //In other languages you may have to release them explicitly.
end;

end.

Mike

Answer 1

Der VarArrayCreate-Aufruf in Ihrem Beispiel erstellt ein Array mit 2 Elementen, das mit Index Null beginnt und mit Index 1 endet.

Das C#-Äquivalent wäre dies:

object[] Line;
Line = new object[2];

Answer 2

Es sollte vielleicht erwähnt werden, dass varArray ein Array des Variant-Datentyps erzeugt, der sich von normalen Typen unterscheidet. Es erzeugt eine Struktur im Speicher, die nicht mit einer Objektinstanz verglichen werden kann (AFAIK). Es wird erwartet, dass es als eine (durch Zeiger) verknüpfte Liste von Knoten gespeichert wird. Die Struktur der Delphi-Variante ist jedoch identisch mit dem Microsoft-eigenen Speicherformat, was bedeutet, dass Sie winapi aufrufen können, um das Gleiche zu erreichen.

Wenn Sie das Problem noch nicht gelöst haben, würde ich einen Blick auf die COM-Unterstützungsbibliotheken in .NET werfen. Wahrscheinlich unter "System.Runtime.InteropServices"". Oder schauen Sie sich die variants.pas Unit in Delphi an und sehen Sie, welche WinAPI-Funktionen sie aufrufen.

Answer 3

private void _showPoints()
{
  object[] pt = new object[2];
  object[] points = new object[4];

  for (int i = 0; i < 3; i++)
  {
    pt[0] = _dx[i, 0];
    pt[1] = _dx[i, 1];
    points[i] = pt;
  }
  _aquaPoints.SetData(points);
}

Oben sehen Sie ein Beispiel für die ShowPoints-Methode aus Alex' VB-Code. Es gilt auch für die Konvertierung des Delphi-Codes, den Sie konvertieren...

Objekt ist das, was einer Variante in C# am nächsten kommt.

Answer 4

Können Sie entweder ein "normales" Array.... erstellen

MyType[] Line = new MyType[2];

oder eine generische Liste....

List<MyType> Line = new List<MyType>(); // list is empty, still have to add n elements
Line.Add( new MyType() );
Line.Add( new MyType() );

Welchen Weg Sie einschlagen, hängt davon ab, was Sie brauchen. Wenn Sie ein "Array" benötigen, das dynamisch wächst, während Ihr Programm läuft, nehmen Sie eine generische Liste, ansonsten ein Array.

Die Sache, die man im Auge behalten muss, ist, dass beide 0-basiert sind und nicht willkürlich bei N beginnen, wie es Delphi tun kann.

Nun, das könnte man mit einer HashTable oder eine Dictionary wenn Sie es brauchen.