Startseite

Über Jürgen A. Becker

Impressum

CAD-Dienstleistungen

Schulungsangebot

Archiv für die Kategorie „DotNet-Programmierung mit C#“

AutoCAD 2011: Debugging .Net-Applikationen innerhalb Visual Studio 2010

Donnerstag, 26. August 2010

Seit ein paar Wochen programmiere ich mit Visual Studio 2010 Professional. Heute habe ich eine laufendes Projekt auf AutoCAD 2011 und Visual Studio 2010 umgestellt und habe dabei festgestellt, dass kein Debuggen möglich ist. Visual studio hält bei keinem Breakpoint an.

Nach sehr frustrierten Stunden mit Debug-Versuchen einer Applikation für AutoCAD 2011 mit Visual Studio 2010 haben ich die Lösung auf Kean Walmsey’s Blog Through the Interface gefunden.

Das Probelm liegt nicht an AutoCAD sondern am VS 2010, weil VS 2010 nicht die richtige Version auswählt um Klassenbibliotheken aus früheren Versionen des .Net-Frameworks zu debuggen. Es wird immer die Deafult-Version, die V4 des .Net-Frameworks gewählt. Diese Version ignoriert Breakpoint in Projekten aus früheren Versionen des .Net.

Kean hat in seinem Blog drei verschiedene Möglichkeiten ausgezeigt, dieses Problem zu lösen.

Ich habe die dritte Möglichkeit ausgewählt:

Fügen Sie die exe-Datei die Ihre Applikation lädt - das ist in diesem Falle AutoCAD -  als existierendes Projekt ihrem Projekt hinzu.

Schritt 1:

AutoCAD als bestehendes Projekt hinzufügen

AutoCAD als bestehendes Projekt hinzufügen

 Schritt 2:

AutoCAD als Startprojekt definieren.

AutoCAD als Startprojekt festlegen

AutoCAD als Startprojekt festlegen

 

Schritt 3:

Die Debug-Version in den Eigenschaften des ACAD-Projektes festlegen.

Debug-Eigenschaft einstellen

Debug-Eigenschaft einstellen

Debug-Version einstellen

Debug-Version einstellen

Danach funktionierte das Debuggen - Setzen eines Breakpoints und Anhalten an dieser Stelle - wunderbar.
Vielen Dank Kean.
Viel Spaß beim AusprobierenAutor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM
  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

AutoCAD und .Net-Framework: Objektwahl und eigene Keywords

Sonntag, 16. Mai 2010

Eine Objektwahl eines einzelnen Objektes ist einfach zu realisieren.
Das Editor-Objekt stellt mit “GetEntity” eine Methode zur Verfügung, welche ein einzelnes Objekt auswählt.
Dazu wird das Objekt “PromptEntityOptions” instanziert und mit der Methode “Add” des Objekts “Keywords” Eingabeoptionen definiert. Die Eigenschaft “Default” definiert ein Default-Schlüsselwort, welches nut mit der Eingabetaste bestätigt werden muss.

Das PromptEntityResult beinhaltet das Ergabeergebnis.

Zunächst wird in einer switch-Anweisung über die Eigenschaft “Status” die Eingabe überprüft.

PromptStatus.Keyword
Die Eingabe war ein Schlüsselwort. In einer weiteren switch-Anweisung wird das eingegebene Schlüsselwort analysiert. Vorteilhaft ist das Umwandeln in Großbuchstaben damit eine Groß- und Kleinschreibung nicht berücksichtigt werden muss.

PromptStatus.OK
Die Eingabe war ein Objekt.

PromptStatus.Cancel
Die Eingabe wurde abgebrochen.

PromptEntityOptions hOpt = new PromptEntityOptions("\n Objekt wählen:");
hOpt.Keywords.Add("Länge");
hOpt.Keywords.Add("Breite");
hOpt.AllowNone = true;
hOpt.Keywords.Default = "Länge";

PromptEntityResult hResult = ed.GetEntity(hOpt);

switch (hResult.Status)
{
    case PromptStatus.Keyword:
       switch (hResult.StringResult.ToUpper())
       {
            case "LÄNGE":

               break;
            case "BREITE":

               break;
       }
       break;
    case PromptStatus.OK:

       break;
    case PromptStatus.Cancel:

      break;
}

 

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

.Net-Framework: Umwandlung von Strings in Zahlenwerten

Montag, 26. April 2010

Sollen Zahlenwerte aus Datenbanken oder XML-Dateien ausglesen werden, stehen diese Zahlenwerte als Datentype string zur Verfügung. Eine Umwandlung ist somit erforderlich.

Ich möchte hier Möglichkeiten vorstellen, wie dieses mit Hilfe von DotNet-Methoden möglich ist.

Möglichkeit 1:

Die Convert-Klasse stellt Methoden zur Umwandlung zur Verfügung.

Beipiel einer Umwandlung in einen Double-Wert.

Convert.ToDouble("1234,45");

Diese Methode birgt eine Gefahr. .Net wirft eine Exception, wenn eine Umwandlung nicht möglich ist.

Möglichkeit 2:
Die Datentyp double besitzt die Methode “TryParse”, die eine Umwandlung versucht. Sie gibt als Ergebnis den umgewandelten Wert und den Erfolg der Umwandlung als boolscher Wert true oder false zurück.
Die Enummerierung System.Globalization.NumberStyles definiert die Art der gewünschten Zahlendarstellung.
Der Ausgabewert als letzter Parameter ist das Ergebnis der Umwandlung.

Jeder weitere Datentyp besitzt diese Methode zur Umwandlung, wobei darauf zu achten ist, dass der NumberStyle und der Ausgabewert dem Datentyp entspricht.

using System.Globalization;


private string hValue = "";
private double doubleVal;
private bool result;
   
Gegebenenfalls ein Komma in einen Punkt oder umgekehrt umwandeln
hValue = hValue.Replace(',', '.');

result =
  double.TryParse(hValue, NumberStyles.Number, null, out doubleVal);
if (result == true)
{
  hString.Wechselrichter.Preis = doubleVal;
}
else
{
  hString.Wechselrichter.Preis = 0.0;
}

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

.Net-Framework: ADO.Net - Datenbankverbindung aufbauen -

Sonntag, 25. April 2010

Nach langer Zeit ohne Blogging möchte ich einige Artikel zum Thema Nutzung von Datenbank in .Net mit Hilfe von ADO.Net.
Dieses Thema hat nicht unmittelbar mit AutoCAD zu tun, ich stelle aber bei vielen Projekten fest, dass eine Nutzung einer SQL-Datenbank z.B. um Stammdaten zu verwalten auch im Umfeld von AutoCAD hilfreich ist.

Der erste Artikel befasst sich mit dem Aufbau einer Datenbankverbindung.

Die Klasse SqlConnection des Namespaces System.Data.SqlClient stellt die Methoden und Eigenschaften ein Datenbankverbindung zur Verfügung.
Um eine Datenbankverbindung aufzubauen, wird ein ConnectionString zusammengesetzt.
Dieser ConnectionString beinhaltet folgende Definition:

Server SQL-Server
Der Datenbank-Servername bestehend aus Computername des Servers auf dem die Datenbank läuft und der Name des SQL-Server.

Microsoft-Access
Wird nicht benötigt.
Data Source SQL-Server
Der Name der Datenbank

Microsoft-Access
Name der Datei
Integrated Security Definiert Art der Anmeldung des Benutzers fest. Ist nur beim SQL-Server anzugeben, da der SQL-Server selbst eine Benutzerberechtigung besitzt. Die Angabe SSPI bedeutet, dass der SQL-Server der Windows-Anmeldung vertraut.

Hier der Code, der eine Datenbankverbindung aufbaut. Er ist Bestandteil einer umfangreichen Datenverbindungklassse, somit ist eine vollständige Anzeige nicht möglich.

switch (hProvider) {
  case "SQLOLEDB":
   if (hServer != null) {
     hConnectionString =
        "Data Source=" + hServer +
        "; Initial Catalog=" + hDataSource +
        "; Integrated security=SSPI";                      
     hSqlConnection = new SqlConnection(hConnectionString);
     hSqlConnection.Open();
     hFehler = 0;                          
  }
  else {
    hFehler = 1;
  }                            
  break;
 case "Microsoft.Jet.OLEDB.4.0":
   hConnectionString =
      "Provider=" + hProvider +
      "; Data Source=" + hDataSource + "; ";
   hConnectionString = hConnectionString +
     "Persist Security Info=False; Mode=ReadWrite;";
   string hCOn = hConnectionString;
   hOleDBConnection =
       new System.Data.OleDb.OleDbConnection(hConnectionString);
   hOleDBConnection.Open();
   hFehler = 0;                            
  break;
}

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

AutoCAD und .Net-Framework: Events im AutoCAD

Freitag, 12. März 2010

Im heutigen Post möchte ich die Events vorstellen, die bei der Nutzung von eigenen und von AutoCAD-Befehlen interessant sind.

Für mich als CAD-Manager ist es u.a wichtig bestimmte Befehle im AutoCAD vor und nach Ausführung abzufangen, um weiteres zu unternehmen.

Events können auch dazu genutzt werden, ganze Befehle zu verbieten oder zu blocken.

Ich möchte hier die Vorgehensweise schrittweise erläutern.

Schritt 1:
In der Initialsierungs-Klasse, sie hat das Interface Autodesk.AutoCAD.Runtime.IExtensionApplication geerbt, werden die Events

  • DocumentLockModeChanged: Wenn ein Befehl aufgerufen wird, wird die Zeichnung gesperrt. Dieses Event kann entsprechend abgefangen werden.
  • DocumentCreateStarted: Wird ein Dokument geöffnet oder neu erstellt, wird dieses Event erzeugt. Mit Abfangen dieses Events können Routinen VORM Erstellen des Dokumentes durchlaufen werden.
  • DocumentCreated: Dieses Event wird erzeugt, wenn das Dokument geladen wurde. Mit Abfangen dieses Events können Routinen NACH Erstellen des Dokumentes durchlaufen werden.

der DokumentCollection generiert.

#region Events für die DocumentsCollection
     DocumentCollection dm = AcAp.DocumentManager;
     dm.DocumentCreated +=
        new DocumentCollectionEventHandler(dm_DocumentCreated);
     dm.DocumentCreateStarted +=
        new DocumentCollectionEventHandler
                 (dm_DocumentCreateStarted);
     dm.DocumentLockModeChanged +=
        new DocumentLockModeChangedEventHandler
                 (dm_DocumentLockModeChanged);
   #endregion

Schritt 2:
Im zweiten Schritt wird definiert was vor und nach dem Laden eines Dokuments geschehen soll.
Ich möchte hier die Events des Objektes Document erläutern, die etwas mit Befehlen zu tun haben.

  • CommandEnded: Wird erzeugt nach Beenden eines Befehls.
  • CommandCancelled: Wird erzeugt, wenn der Befehl abgebrochen wurde.
  • CommandWillStart: Wird vor der Ausführung des Befehls erzeugt.
#region DocumentEvents
     hDoc.CommandEnded +=
       new CommandEventHandler(hDoc_CommandEnded);         
     hDoc.CommandCancelled +=
       new CommandEventHandler(hDoc_CommandCancelled);
     hDoc.CommandWillStart +=
       new CommandEventHandler(hDoc_CommandWillStart);
   #endregion

In den einzelnen Eventmethoden, werden die Befehlsnamen abgefragt. Der Befehlsname ist die Eigenschaft GlobalCommandName der Event-Argumente (im Beispiel weiter unten die Variable e). Der Befehlsname ist der englische und wird in einer switch-Anweisung verarbeitet.

Das Dokumenten-Objekt ist der Übergabeparameter sender und muss in das Objekt Document gecastet werden.

Beispiel für das Event CommandEnded

Document hDoc = (Document)sender;      
   switch(e.GlobalCommandName)
   {
     case "COPY":
      //Do what ever you want  
      break;
   }

Hier der vollständige Code für die Initialisierungs-Klasse

using AcAp = Autodesk.AutoCAD.ApplicationServices.Application;

.
.
.

public class clsInitialize :
         Autodesk.AutoCAD.Runtime.IExtensionApplication
{        
 public void Initialize()
 {
   Document hDoc = AcAp.DocumentManager.MdiActiveDocument;
   Database hDb = hDoc.Database;

   #region Events für die akutelle Zeichnung
    hDoc.CommandCancelled +=
      new CommandEventHandler(hDoc_CommandCancelled);
    hDoc.CommandEnded +=
      new CommandEventHandler(hDoc_CommandEnded);  
    hDoc.CommandWillStart +=
      new CommandEventHandler(hDoc_CommandWillStart);
   #endregion
           
   #region DatabaseEvents
     hDb.BeginSave += new DatabaseIOEventHandler(hDb_BeginSave);
   #endregion          
           
   #region Events für die DocumentsCollection
     DocumentCollection dm = AcAp.DocumentManager;
     dm.DocumentCreated +=
        new DocumentCollectionEventHandler(dm_DocumentCreated);
     dm.DocumentCreateStarted +=
        new DocumentCollectionEventHandler
                 (dm_DocumentCreateStarted);
     dm.DocumentLockModeChanged +=
        new DocumentLockModeChangedEventHandler
                 (dm_DocumentLockModeChanged);
   #endregion
 }
       
 public void Terminate()
 {

 }        
       
 void dm_DocumentLockModeChanged
    (object sender, DocumentLockModeChangedEventArgs e)
 {
   DocumentCollection hDocCol = (DocumentCollection)sender;
   switch(e.GlobalCommandName)
   {
      case "":

         break;
   }
 }
       
 void dm_DocumentCreateStarted
      (object sender, DocumentCollectionEventArgs e)
 {

 }

 void dm_DocumentCreated
      (object sender, DocumentCollectionEventArgs e)
 {
   Document hDoc = AcAp.DocumentManager.MdiActiveDocument;
   Database hDb = hDoc.Database;
   #region DocumentEvents
     hDoc.CommandEnded +=
       new CommandEventHandler(hDoc_CommandEnded);         
     hDoc.CommandCancelled +=
       new CommandEventHandler(hDoc_CommandCancelled);
     hDoc.CommandWillStart +=
       new CommandEventHandler(hDoc_CommandWillStart);
   #endregion
           
   #region DatabaseEvents
      hDb.BeginSave += new DatabaseIOEventHandler(hDb_BeginSave);
   #endregion
 }

 void hDb_BeginSave(object sender, DatabaseIOEventArgs e)
 {

 }

 void hDoc_CommandWillStart(object sender, CommandEventArgs e)
 {
   Document hDoc = (Document)sender;        
   switch(e.GlobalCommandName)
   {
     case "":
                   
      break;
   }
 }

 void hDoc_CommandCancelled(object sender, CommandEventArgs e)
 {
   Document hDoc =(Document)sender;        
   switch(e.GlobalCommandName)
   {
      case"":
                   
         break;
   }
 }

 void hDoc_CommandEnded(object sender, CommandEventArgs e)
 {
   Document hDoc =(Document)sender;        
   switch(e.GlobalCommandName)
   {
      case"":
                   
         break;
   }
 }
}

Ein Beispiel zeigt der Artikel von Kean Walmsey Blocking AutoCAD commands from .NET.

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

AutoCAD und .Net-Framework - Wie wird der Optionsdialog innerhalb eines eigenen Formulars aufgerufen? -

Donnerstag, 4. Februar 2010

Der Options-Dialog kann mit Hilfe einer SendCommand-Anweisung aufgerufen werden, da diese Anweisung asynchron aufgerufen wird, wird sie in die Befehls-Warteschlange eingereiht und erst nach Beendung eines aktiven befehls ausgeführt.

Aus diesem Grunde ist es nicht sinnvoll zum Aufruf des Options-Dialoges innerhalb eines eigenen Formulars die SendCommand-Methode oder eine ähnliche zu nutzen.

Im Internal Namespace innerhalb der Klasse Utils befindet sich die Methode:

Autodesk.AutoCAD.Internal.Utils.InvokeOptionsDialog
    ("System", false, 0, false);

Diese Methode ruft den Optionsdialog auf.
Die Übergabe-Parameter sind nicht klar, da keine Dokumentation zu dieser Klasse zufinden ist.
Der erste Parameter ist der Name des Registers, das beim Aufruf angezeigt werden soll.

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

AutoCAD und .Net-Framework - Eigenes Register im Optionsdialog -

Donnerstag, 4. Februar 2010

Eigene Applikationen sollten soweit wie möglich skalierbar programmiert werden, d.h. Einstellungen für die Applikation (Texthöhen, Layer etc.) sollten innerhalb eines Optionsdialoges definierbar sein.
Vorteilhaft wäre es, wenn der eigene Optionsdialog innerhalb des AutoCAD-Optionsdialoges integriert würde.
Ich möchte hier erläutern wie dieses in .Net zu realisieren ist.

Zunächst wird ein Event initialisert. Dieses Event sorgt dafür, das eine Ereignis-Methode (hier: Application_DisplayingOptionDialog) aufgerufen wird.

Application.DisplayingOptionDialog +=
    new TabbedDialogEventHandler(Application_DisplayingOptionDialog);

Im Folgenden stelle ich den Code vor, der beim Aufruf des Options-Befehls aufgerufen wird. Im Deklarationsbereich muss dazu noch folgende Deklaration vorgenommen werden:

static usrOptions hUSROptions;
private static void Application_DisplayingOptionDialog
    (object sender, TabbedDialogEventArgs e)
{
if (hUSROptions == null) hUSROptions = new usrOptions();
TabbedDialogExtension tde =
    new TabbedDialogExtension(
        hUSROptions,
        new TabbedDialogAction(OnOptions)
    );

    e.AddTab("Eigenes Register", tde);
}

Die Ereignis-Methode, muss in der Initialisierungs-Klasse implementiert werden.
Der folgende Code stellt die Struktur der Initialisierungs-Klasse dar.

public class clsCADBecker : Autodesk.AutoCAD.Runtime.IExtensionApplication
{
  public clsCADBecker () {...}

  public void Initialize()
  {
  Application.DisplayingOptionDialog +=
      new TabbedDialogEventHandler(Application_DisplayingOptionDialog);
   }

  public void Terminate(){...}

  private static void Application_DisplayingOptionDialog
     (object sender, TabbedDialogEventArgs e) {...}

}

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

AutoCAD und .Net-Framework - Aufruf von Befehlen im .Net -

Dienstag, 2. Februar 2010

Ich möchte in diesem Artikeln den Aufruf von AutoCAD-Befehlen innerhalb einer .Net-Applikatoin erläutern. Das Aufrufen kann mit Hilfe unterschiedlichster Methoden geschehen.

  • SendStringToExecute-Methode des managed document object
  • SendCommand-Methode des COM-Dokumenten Objektes
  • acedPostCommand via P/Invoke
  • ads_queueexpr() via P/Invoke

Zunächst ist zweiusings und eine COM Referenzierung zur AutoCAD Type-Library erforderlich.

using System.Runtime.InteropServices;
using Autodesk.AutoCAD.Interop;

Folgende Deklarationen sind

using System.Runtime.InteropServices;
using Autodesk.AutoCAD.Interop;

namespace CADBecker
{
 public class clsCommands
 {
  [DllImport("acad.exe", CharSet = CharSet.Auto,
     CallingConvention = CallingConvention.Cdecl)]
  extern static private int ads_queueexpr(string strExpr);

  [DllImport("acad.exe", CharSet = CharSet.Auto,
     CallingConvention = CallingConvention.Cdecl,
     EntryPoint = "?acedPostCommand@@YAHPB_W@Z")]
  extern static private int acedPostCommand(string strExpr);
 }
}

Methode SendStringToExecute

Hier wird der Options-Dialog aufgerufen.
By the Way: Der Parameter 0 in meinem Bespiel ruft das zuletzt genutzte Register auf.

Document doc = AcAp.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
doc.SendStringToExecute("_+options 0", false, false, true);

Methode SendCommand

Hierbei wird die Methode SendCommand des Objektes ActiveDocument aufgerufen.

AcadApplication App =
  (AcadApplication)Autodesk.AutoCAD.ApplicationServices.Application;
    App.ActiveDocument.SendCommand("_+options 0");

Aufruf von acedPostCommand via P/Invoke

acedPostCommand("_+options 0");

Aufruf von ads_queueexpr() via P/Invoke

ads_queueexpr("(command "" _POINT "" ""4,4,0"")")

Hier finden Sie den Original Artikel Calling AutoCAD commands from .NET von Kean Walmsey’s Through the Interface

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

AutoCAD und .Net-Framework - Filtern der Zeichnung anhand von Extented Entity Datas -

Freitag, 29. Januar 2010

In einigen der vorherigen Artikeln habe ich das Anhängen von Daten an Objekten erläutert.
In diesen Artikeln möchte ich erläutern wie Objekte anhand ihrer Extended Entity Data gefunden werden können.

Im folgenden Beispiel werden die Objekte gefunden, denen der registrierte Applikations-Name “GUID” und ein spezieller unique Identifier (gespeichert in der Variable hGuid) angehängt wurde.

TypedValue[] hTv = new TypedValue[2];
hTv.SetValue(
     new TypedValue((int)DxfCode.ExtendedDataAsciiString, hGuid), 0);
hTv.SetValue(
     new TypedValue((int)DxfCode.ExtendedDataRegAppName, "GUID"), 1);
                   
SelectionFilter sf = new SelectionFilter(hTv);
hSelectionSet = ed.SelectAll(sf);

Die in der Online-Dokumentation für .Net-Entwickler gezeigt Möglichkeit mit der Methode GetSelection() des Editors ist nicht korrekt, da sie eine Auswahl des Benutzers erwartet. Sie läuft bei mir auf einen Fehler.

hSelectionSet = ed.GetSelection(sf)

Es ist anscheinend auch so, dass nur die Objekte gefunden werden, denen nur diese Daten als Extended Entity Data angehängt wurden. Sind mehrere Daten unterschiedlicher Applikationen angehängt worden, werden sie nicht mehr gefunden.

Fazit: AutoCAD unterstützt nur das Suchen nach einen Applikationsnamen korrekt. Der Wert verursahct Fehler.

Im folgenden Codebeispiel werden die Objekte gesucht, die einen Applikatiuonsnamen “GUID” angehängt bekommen haben. Der Wert der Applikation muss explizit abgefragt werden.
In einer foreach-Schleife werden die gefundenen Objekte durchlaufen und auf den Guid-Wert überprüft. Ist der gewünschte gefunden, wird das Objekt in einer if-Schleife bearbeitet.

TypedValue[] hTv = new TypedValue[1];
hTv.SetValue(
     new TypedValue((int)DxfCode.ExtendedDataRegAppName, "GUID"), 0);
                       
SelectionFilter sf = new SelectionFilter(hTv);
hSelectionSet = ed.SelectAll(sf);
foreach (SelectedObject hObject in hSelectionSet.Value)
{
 Entity hObj =
      (Entity)tm.GetObject(hObject.ObjectId, OpenMode.ForRead, true);
 TypedValue hTypeValue =
      hXData.GetXData(hObj.ObjectId, "STRINGGUID");
 string hValue = (string)hTypeValue.Value;
                                                             
 if (hValue == hGuid)
 {
     
 }

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

AutoCAD und .Net-Framework - Entfernen von Extended Entity Datas -

Donnerstag, 28. Januar 2010

Als Ergänzung zur Reihe “AutoCAD 2010 und .Net-Framework - Verwalten von eigenen Daten innerhalb einer Zeichnung”

Ich habe lange versucht XData mit .Net von einem Objekt zu entfernen und bin auf eine simple Lösung gestoßen - hoffentlich funktioniert sie auch -.

Es wird der Methode REMOVEXDATA die ObjektID und der Applikationsname der gelöscht werden soll übergeben. Der Wert des Applikationsnamens fehlt. Der ResultBuffer besteht somit nur aus dem Applikationsnamen und anscheinend wird AutoCAD diesen Applikationsnamen dann vollständig aus den XData’s entfernen.

public void RemoveXData(ObjectId ObjectID, string ApplicationName)
{
 Document doc = AcAp.DocumentManager.MdiActiveDocument;
 Editor ed = doc.Editor;
 Transaction hTr = doc.TransactionManager.StartTransaction();
 using (hTr)
 {
  try
  {
   ResultBuffer hResBuffer = new ResultBuffer(
       new TypedValue(1001, ApplicationName));
       DBObject hObject = hTr.GetObject(
       ObjectID,
       OpenMode.ForWrite
       );
   hObject.XData = hResBuffer;
   hResBuffer.Dispose();                  
  }
  catch
  {
  }
  hTr.Commit();
 }
}

Diese Methode ist Mitglied der Klasse clsXdata, die weiter unten vorgestellt habe.

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung