Author Topic: Creating an associative hatch in C# causes access violation (Read 8019 times)

akaranta · « **on:** September 30, 2015, 06:54:34 AM »

I wrote code to programmatically (in C#) create a hatch that I first created interactively, i.e. the properties of the bounding polyline, the hatch and the hatch loop are taken from that real case. The problem is that I get access violation when calling AppendLoop method.

Here's the code - it is easy to copy-paste into a class and run using the command NSASSOCHATCH

Code - C#: [Select]

[CommandMethod( "NSASSOCHATCH" )]
public static void AssocHatch() {
    var doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
    using ( var tx = doc.TransactionManager.StartTransaction() ) {
        var polyline = CreatePolyline();
        AddEntity( tx, doc.Database, polyline );
        polyline.Layer = "0";
 
        CreateHatch( doc, tx, polyline );
 
        tx.Commit();
    }
}
 
private static readonly EntityColor __color = new EntityColor( ColorMethod.ByLayer, 256 );
 
 
private static Hatch CreateHatch( Autodesk.AutoCAD.ApplicationServices.Document doc, Transaction tx, Polyline boundary ) {
    var h = new Hatch();
 
    h.SetHatchPattern( HatchPatternType.PreDefined, "ANGLE" );
    h.HatchObjectType = HatchObjectType.HatchObject;
 
    //using ( var c = Color.FromEntityColor( __bgColor ) ) {
    //    h.BackgroundColor = c;
    //}
 
    h.SetGradient( GradientPatternType.PreDefinedGradient, "LINEAR" );
    h.GradientAngle = 0;
    h.GradientOneColorMode = false;
    h.GradientShift = 0;
 
    h.HatchStyle = HatchStyle.Outer;
 
    h.Normal = new Vector3d( 0, 0, 1 );
    h.Origin = new Point2d( 0, 0 );
 
    h.PatternAngle = 0;
    h.PatternDouble = false;
    h.PatternScale = 1.0;
    h.PatternSpace = 1.0;
 
    var gradientColors = new GradientColor[] { new GradientColor( Color.FromColorIndex( ColorMethod.ByAci, 5 ) , 0),
                                               new GradientColor( Color.FromColorIndex( ColorMethod.ByAci, 2 ), 1)};
 
    h.SetGradientColors( gradientColors );
    // according to http://adndevblog.typepad.com/autocad/2012/07/hatch-using-the-autocad-net-api.html
    // the pattern needs to be "reaffirmed"
    h.SetHatchPattern( HatchPatternType.PreDefined, "ANGLE" );
 
    // add to db before making hatch associative
    AddEntity( tx, doc.Database, h );
 
    h.Associative = true;
 
    var boundaryColl = new ObjectIdCollection( new [] { boundary.ObjectId } );
    // this call causes access violation
    h.AppendLoop( HatchLoopTypes.Derived | HatchLoopTypes.Polyline | HatchLoopTypes.External, boundaryColl );
 
    h.EvaluateHatch( true );
 
    return h;
}
 
private static Polyline CreatePolyline() {
    var polyline = new Polyline( 5 );
    polyline.Normal = new Vector3d( 0.0, 0.0, 1.0 );
    // changing this to true does not help to the access violation
    polyline.Closed = false;
    using ( var c = Color.FromEntityColor( __color ) ) {
        polyline.Color = c;
    }
 
    var startPoint = new Point2d( -1689.42165011024, 992.835483259347 );
 
    polyline.AddVertexAt( 0, startPoint, 0, 0, 0 );
    polyline.AddVertexAt( 1, new Point2d( -551.330950840098, 109.713933732506 ), 0, 0, 0 );
    polyline.AddVertexAt( 2, new Point2d( 29.8217540440291, 1216.64025798278 ), 0, 0, 0 );
    polyline.AddVertexAt( 3, new Point2d( 1052.89265151563, 1313.42070640714 ), 0, 0, 0 );
    polyline.AddVertexAt( 4, startPoint, 0, 0, 0 );
 
    polyline.MinimizeMemory();
 
    return polyline;
}
 
private static ObjectId AddEntity( Transaction tx, Database db, Entity e ) {
    var btr = (BlockTableRecord)tx.GetObject( SymbolUtilityServices.GetBlockModelSpaceId( db ), OpenMode.ForWrite );
    var oid = btr.AppendEntity( e );
    e.SetDatabaseDefaults( db );
    tx.AddNewlyCreatedDBObject( e, true );
    return oid;
}
 

Environment: windows 7 on x64 (also occurs at least on windows

, AutoCAD 2015

Ps. I have also posted this question to the AutoCAD forum at http://forums.autodesk.com/t5/autocad-2013-2014-2015-2016/creating-an-associative-hatch-in-c-causes-access-violation/td-p/5836968

Jeff H · « **Reply #1 on:** September 30, 2015, 03:41:33 PM »

Welcome to the Swamp!

Seems like hatches are like mleaders sometimes where the order you set properties can cause problems.
Will have a little more time later to look at it but if seems right could just be order the properties are set.

Bryco · « **Reply #2 on:** October 02, 2015, 07:59:57 PM »

Closing the pline help?

Kerry · « **Reply #3 on:** October 02, 2015, 09:32:35 PM »

I believe the problem is associated with adding the Pattern as well as the Gradient.

I also committed the pline before adding the hatch.
I left the pline not closed.

tested in AutoCAD 2016 on Win10
Hope that helps.

Code - C#: [Select]

using System;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Colors;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.EditorInput;
 
[assembly: CommandClass(typeof(NSASSOCHATCH.MyCommands))]
 
namespace NSASSOCHATCH {
    public class MyCommands {
        [CommandMethod("NSASSOCHATCH")]
        public static void AssocHatch() {
            var doc =
                Autodesk.AutoCAD.ApplicationServices.Core.Application.DocumentManager
                        .MdiActiveDocument;
            var polyline = new Polyline();
 
            using(var tx = doc.TransactionManager.StartTransaction()) {
                polyline = CreatePolyline();
                AddEntity(tx, doc.Database, polyline);
                polyline.Layer = "0";
                tx.Commit();
            }
            using(var tx = doc.TransactionManager.StartTransaction()) {
                CreateHatch(doc, tx, polyline);
                tx.Commit();
            }
        }
 
        private static readonly EntityColor __color = new EntityColor(ColorMethod.ByLayer, 256);
 
        private static Hatch CreateHatch(Document doc, Transaction tx, Polyline boundary) {
            var h = new Hatch();
 
            // // ***revised
            // h.SetHatchPattern(HatchPatternType.PreDefined, "ANGLE");
 
            // h.HatchObjectType = HatchObjectType.HatchObject;
            h.HatchObjectType = HatchObjectType.GradientObject;
 
            //using ( var c = Color.FromEntityColor( __bgColor ) ) {
            //    h.BackgroundColor = c;
            //}
 
            h.SetGradient(GradientPatternType.PreDefinedGradient, "LINEAR");
            // h.GradientAngle = 0;
            h.GradientAngle = 0.0;
            h.GradientOneColorMode = false;
            h.GradientShift = 0;
 
            h.HatchStyle = HatchStyle.Outer;
 
            h.Normal = new Vector3d(0, 0, 1);
            h.Origin = new Point2d(0, 0);
 
            // h.PatternAngle = 0;          // ***revised
            // h.PatternAngle = 0.0;        // ***revised
            // h.PatternDouble = false;     // ***revised
            // h.PatternScale = 1.0;        // ***revised
            // h.PatternSpace = 1.0;        // ***revised
 
            var gradientColors = new GradientColor[] {
                                                         new GradientColor(
                                                             Color.FromColorIndex(ColorMethod.ByAci,5),0),
                                                         new GradientColor(
                                                             Color.FromColorIndex(ColorMethod.ByAci,2),1)
                                                     };
            h.SetGradientColors(gradientColors);
            // according to http://adndevblog.typepad.com/autocad/2012/07/hatch-using-the-autocad-net-api.html
            // the pattern needs to be "reaffirmed"
 
            // ***revised
            // h.SetHatchPattern(HatchPatternType.PreDefined, "ANGLE");
 
            // add to db before making hatch associative
            AddEntity(tx, doc.Database, h);
 
            h.Associative = true;
 
            var boundaryColl = new ObjectIdCollection(new[] { boundary.ObjectId });
            // this call causes access violation
            h.AppendLoop(
                         // ***revised HatchLoopTypes.Derived | HatchLoopTypes.Polyline |
                         // ***revised HatchLoopTypes.External,
                         HatchLoopTypes.Default,
                         boundaryColl);
 
            h.EvaluateHatch(true);
 
            return h;
        }
 
        private static Polyline CreatePolyline() {
            var polyline = new Polyline(5);
            polyline.Normal = new Vector3d(0.0, 0.0, 1.0);
            // changing this to true does not help to the access violation
            polyline.Closed = false;
 
            using(var c = Color.FromEntityColor(__color)) {
                polyline.Color = c;
            }
 
            var startPoint = new Point2d(-1689.42165011024, 992.835483259347);
 
            polyline.AddVertexAt(0, startPoint, 0, 0, 0);
            polyline.AddVertexAt(1,
                                 new Point2d(-551.330950840098, 109.713933732506),
                                 0, 0, 0);
            polyline.AddVertexAt(2,
                                 new Point2d(29.8217540440291, 1216.64025798278),
                                 0, 0, 0);
            polyline.AddVertexAt(3,
                                 new Point2d(1052.89265151563, 1313.42070640714),
                                 0, 0, 0);
 
            polyline.AddVertexAt(4, startPoint, 0, 0, 0);
 
            polyline.MinimizeMemory();
 
            return polyline;
        }
 
        private static ObjectId AddEntity(Transaction tx, Database db, Entity e) {
            var btr =
                (BlockTableRecord)
                tx.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db),
                             OpenMode.ForWrite);
            var oid = btr.AppendEntity(e);
            e.SetDatabaseDefaults(db);
            tx.AddNewlyCreatedDBObject(e, true);
            return oid;
        }
 
    }
}
 
 

akaranta · « **Reply #4 on:** October 06, 2015, 06:30:19 AM »

Thank you Kerry!

This is a huge step forward for me in this issue. Unoftunately it is not quite yet resolved - I still get an access violation when trying to create a hatch, not a gradient.

A bit of background - I need to programmatically extract the properties of an AutoCAD object and recreate / modify a corresponding object in another AutoCAD instance.

If I understood you right, some of the Hatch class' properties are only applicable when HatchObjectType == HatchObjectType.HatchObject and others only when HatchObjectType == HatchObjectType.GradientObject?
All the properties I set in the code were read from a real live Hatch object. In order to reproduce this object I only need to take care of the relevant subset of the hatch properties?

With that in mind I revised the original code like so (note that the original object was a hatch, not a gradient):

Code - C#: [Select]

        private static Hatch CreateHatch( Autodesk.AutoCAD.ApplicationServices.Document doc, Transaction tx, Polyline boundary, HatchObjectType htype = HatchObjectType.HatchObject ) {
            var h = new Hatch();
 
            h.HatchObjectType = htype;
            if ( h.HatchObjectType == HatchObjectType.HatchObject ) {
                h.SetHatchPattern( HatchPatternType.PreDefined, "ANGLE" );
            }
 
            if ( h.HatchObjectType == HatchObjectType.GradientObject ) {
                h.SetGradient( GradientPatternType.PreDefinedGradient, "LINEAR" );
                h.GradientAngle = 0;
                h.GradientOneColorMode = false;
                h.GradientShift = 0;
                var gradientColors = new GradientColor[] { new GradientColor( Color.FromColorIndex( ColorMethod.ByAci, 5 ) , 0),
                                                       new GradientColor( Color.FromColorIndex( ColorMethod.ByAci, 2 ), 1)};
 
                h.SetGradientColors( gradientColors );
            }
 
            if ( h.HatchObjectType == HatchObjectType.HatchObject ) {
                h.HatchStyle = HatchStyle.Outer;
 
                h.Normal = new Vector3d( 0, 0, 1 );
                h.Origin = new Point2d( 0, 0 );
 
                h.PatternAngle = 0;
                h.PatternDouble = false;
                h.PatternScale = 1.0;
                h.PatternSpace = 1.0;
            }
 
            // according to http://adndevblog.typepad.com/autocad/2012/07/hatch-using-the-autocad-net-api.html
            // the pattern needs to be "reaffirmed"
            if ( h.HatchObjectType == HatchObjectType.HatchObject ) {
                h.SetHatchPattern( HatchPatternType.PreDefined, "ANGLE" );
            }
 
            // add to db before making hatch associative
            AddEntity( tx, doc.Database, h );
 
            h.Associative = true;
 
            var boundaryColl = new ObjectIdCollection( new [] { boundary.ObjectId } );
            // this call causes access violation
            h.AppendLoop( HatchLoopTypes.Derived | HatchLoopTypes.Polyline | HatchLoopTypes.External, boundaryColl );
 
            h.EvaluateHatch( true );
 
            return h;
        }
 

I still get an access violation from the AppendLoop method.

Am I still setting some properties I should not or missing properties I should set?

Ps. A secondary question - do I need to Dispose of the ObjectIdCollection myself or will the hatch object attain its "ownership" (and Dispose of it when needed) when I give the loop to the hatch object via AppendLoop? This is not really clean in the docs IMO. Or maybe I missed it?

Kerry · « **Reply #5 on:** October 06, 2015, 07:02:29 AM »

I don't use hatches very much ...

I thought we could fill existing objects or enclosed areas with either hatch patterns, solid color fills, or gradients.

I wasn't aware that they could be combined into ONE object.

Can you post the drawing with the hatch object you used as a template ??

ADDED:
Re-reading your last post.
It appears you ARE trying to only apply ONE type.

Personally, I'd make one function for each option rather than jump through hoops in the builder.

I'm off to bed now, so could you please post (at your leisure ) the complete class source.
I'll have a look tomorrow.

ADDED:

Your post at the AutoDesk Discussion Group may have been better located in the .NET forum.
http://forums.autodesk.com/t5/net/bd-p/152

Kerry · « **Reply #6 on:** October 07, 2015, 09:35:31 AM »

See if this suits you ...

First, the result then the code layout.
The next post will have the code commands and methods.

This is the way I'd do it ... subject to the result spec's and the work flow requirements.
Note the nested using statements.
... and the parameters passed to the Polyline and Hatch generators.

Note that the vector calculations are base on X,Y pairs for each leg, not the absolute location.
This is easy to modify, it just suited my sample using the same shape for the examples.
It may suit you to generate a collection of vertex points in the main module and pass that collection to the generator.

The code has not been reviewed, it'sjust proof of concept code
... due care and no responsibility

Kerry · « **Reply #7 on:** October 07, 2015, 09:45:24 AM »

The code ... just add each to the class
The Source Zip is attached at the bottom of the post.

Code - C#: [Select]

// codehimbelonga kdub@theSwamp  
// Oct 2015 // for http://www.theswamp.org/index.php?topic=50188.msg553449#msg553449
using System;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Colors;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using AcadApp = Autodesk.AutoCAD.ApplicationServices.Core.Application;
 
[assembly: CommandClass(typeof(NSASSOCHATCH.MyHatchTestingCommands))]
 
namespace NSASSOCHATCH {
    public class MyHatchTestingCommands {
 
}
 

Code - C#: [Select]

        [CommandMethod("AH01")]
        public static void AddHatch01() {
            var doc = AcadApp.DocumentManager.MdiActiveDocument;
            var db = doc.Database;
            using(var tr = doc.TransactionManager.StartTransaction()) {
                var bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead)
                         as BlockTable;
                var br = tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite)
                         as BlockTableRecord;
 
                using(Circle circ = new Circle()) {
                    circ.Center = new Point3d(5, 5, 0);
                    circ.Radius = 50;
 
                    br.AppendEntity(circ);
                    tr.AddNewlyCreatedDBObject(circ, true);
 
                    var objIdColl = new ObjectIdCollection();
                    objIdColl.Add(circ.ObjectId);
 
 
                    using(Hatch hatch = new Hatch()) {
                        br.AppendEntity(hatch);
                        tr.AddNewlyCreatedDBObject(hatch, true);
                        CreateHatchPattern(hatch, "ANGLE", objIdColl);
                    }
                }
                tr.Commit();
            }
        }
 

Code - C#: [Select]

        [CommandMethod("AH02")]
        public static void AddHatch02() {
            var doc = AcadApp.DocumentManager.MdiActiveDocument;
            var db = doc.Database;
            using(var tr = doc.TransactionManager.StartTransaction()) {
                var bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead)
                         as BlockTable;
                var br = tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite)
                         as BlockTableRecord;
 
                using(Circle circ = new Circle()) {
                    circ.Center = new Point3d(100, 5, 0);
                    circ.Radius = 50;
 
                    br.AppendEntity(circ);
                    tr.AddNewlyCreatedDBObject(circ, true);
 
                    var objIdColl = new ObjectIdCollection();
                    objIdColl.Add(circ.ObjectId);
 
                    using(Hatch hatch = new Hatch()) {
                        br.AppendEntity(hatch);
                        tr.AddNewlyCreatedDBObject(hatch, true);
                        CreateHatchGradient(hatch, "LINEAR", objIdColl, 2, 5);
                    }
                }
                tr.Commit();
            }
        }
 

Code - C#: [Select]

        [CommandMethod("AH03")]
        public static void AddHatch03() {
            var doc = AcadApp.DocumentManager.MdiActiveDocument;
            var db = doc.Database;
            using(var tr = doc.TransactionManager.StartTransaction()) {
                var bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead)
                         as BlockTable;
                var br = tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite)
                         as BlockTableRecord;
 
                using(Polyline pline = new Polyline()) {
                    CreatePolyShape(pline, new Point2d(150, 10));
                    br.AppendEntity(pline);
                    tr.AddNewlyCreatedDBObject(pline, true);
 
                    var objIdColl = new ObjectIdCollection();
                    objIdColl.Add(pline.ObjectId);
 
                    using(Hatch hatch = new Hatch()) {
                        br.AppendEntity(hatch);
                        tr.AddNewlyCreatedDBObject(hatch, true);
                        CreateHatchPattern(hatch, "ANGLE", objIdColl);
                    }
                }
                tr.Commit();
            }
        }
 

Code - C#: [Select]

        [CommandMethod("AH04")]
        public static void AddHatch04() {
            var doc = AcadApp.DocumentManager.MdiActiveDocument;
            var db = doc.Database;
            using(var tr = doc.TransactionManager.StartTransaction()) {
                var bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead)
                         as BlockTable;
                var br = tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite)
                         as BlockTableRecord;
 
                using(Polyline pline = new Polyline()) {
                    CreatePolyShape(pline, new Point2d(130, 75));
                    br.AppendEntity(pline);
                    tr.AddNewlyCreatedDBObject(pline, true);
 
                    var objIdColl = new ObjectIdCollection();
                    objIdColl.Add(pline.ObjectId);
 
                    using(Hatch hatch = new Hatch()) {
                        br.AppendEntity(hatch);
                        tr.AddNewlyCreatedDBObject(hatch, true);
                        CreateHatchGradient(hatch, "LINEAR", objIdColl, 5, 2);
                    }
                }
                tr.Commit();
            }
        }
 

Code - C#: [Select]

        private static readonly EntityColor __color = new EntityColor(ColorMethod.ByLayer, 256);
        //===========================================
        private static void CreatePolyShape(Polyline pline, Point2d startPoint) {
            pline.Normal = new Vector3d(0.0, 0.0, 1.0);
            pline.Color = Color.FromEntityColor(__color);
            pline.Closed = true;
 
            pline.AddVertexAt(0, startPoint, 0, 0, 0);
            pline.AddVertexAt(1, startPoint.Add(new Vector2d(200, 10)), 0, 0, 0);
            pline.AddVertexAt(2, startPoint.Add(new Vector2d(70, 20)), 0, 0, 0);
            pline.AddVertexAt(3, startPoint.Add(new Vector2d(80, -50)), 0, 0, 0);
            pline.AddVertexAt(4, startPoint.Add(new Vector2d(50, -40)), 0, 0, 0);
            pline.MinimizeMemory();
        }
 

Code - C#: [Select]

        private static void CreateHatchPattern(Hatch hatch,
                                                String patternName,
                                                ObjectIdCollection boundaryCollection) {
            // Set associative after appending and before AppendLoop
            hatch.SetHatchPattern(HatchPatternType.PreDefined, patternName);
            hatch.Associative = true;
            hatch.AppendLoop(HatchLoopTypes.Outermost, boundaryCollection);
            hatch.EvaluateHatch(true);
        }
        //===========================================
        private static void CreateHatchGradient(Hatch hatch,
                                                String gradientName,
                                                ObjectIdCollection boundaryCollection,
                                                short colorIndex0,
                                                short colorIndex1) {
            // Set associative after appending and before AppendLoop
            hatch.HatchObjectType = HatchObjectType.GradientObject;
            hatch.SetGradient(GradientPatternType.PreDefinedGradient, gradientName);
            hatch.GradientOneColorMode = false;
            hatch.GradientShift = 0;
            var gradientColors = new GradientColor[] {
                                                         new GradientColor(
                                                             Color.FromColorIndex(ColorMethod.ByAci,
                                                                                  colorIndex0), 0),
                                                         new GradientColor(
                                                             Color.FromColorIndex(ColorMethod.ByAci,
                                                                                  colorIndex1), 1)
                                                     };
            hatch.SetGradientColors(gradientColors);
            hatch.Associative = true;
            hatch.AppendLoop(HatchLoopTypes.Outermost, boundaryCollection);
            hatch.EvaluateHatch(true);
        }
 

Kerry · « **Reply #8 on:** October 08, 2015, 08:24:22 AM »

I'd recommend that you start with this working example and progressively add code ( to match the properties in your code).
You may be able to discover the cause of the error in your code.

Kerry · « **Reply #9 on:** October 15, 2015, 10:09:34 AM »

Was this ever followed up ??

Any issues ?

akaranta · « **Reply #10 on:** October 18, 2015, 06:53:14 AM »

Sorry, I got a more urgent matter to take care of and had to postpone resolving this a little bit. I'll likely return to it in a week.

Thank you very much for your advice and code, I will certainly use it as the basis for further experiments. I will post a reply to this topic to let you know how it goes and of any further findings / solutions.

akaranta · « **Reply #11 on:** November 04, 2015, 03:42:24 AM »

I have now been investigating the issue some more and the access violation is clearly connected to the HatchLoopTypes enum values used in calls to AppendLoop.

At least these work ok:

HatchLoopTypes.External
HatchLoopTypes.Derived | HatchLoopTypes.External

At least these crash:

HatchLoopTypes.Derived | HatchLoopTypes.Polyline | HatchLoopTypes.External // my original case
HatchLoopTypes.Polyline | HatchLoopTypes.External

Looking at the documentation of the HatchLoopTypes enumeration it seems a little strange that HatchLoopTypes.Polyline should be combined with HatchLoopTypes.External as the former implies there are specific defining objects e.g. AutoCAD.Geometry.CircularArc2d. However, in this case the hatch is associative and this particular loop is (logically) External as it used a database resident polyline entity as a boundary.
And, like I stated before, this is the state I read from a hatch object I created.

At least to me it is not clear from the documentation which combinations of this enum's values are legal and which are not. And it is not at all clear how I can reproduce a hatch entity like the one I took this state from.

I will continue investigating, any hints highly appreciated...

Kerry · « **Reply #12 on:** November 04, 2015, 03:54:21 AM »

How about you produce a drawing that contains samples of what works and what doesn't with the LoopTypes nominated on the drawing.

Or generate code samples that demonstrate the issue.
Are you attempting to apply a generic LoopType to all your polylines ??

We'll need more information to resolve the issue.
And you will need reproducible failures if you expect AutoDesk to look at the situation.

I'll need a better indicator of the situation that causes the errors and I'd need to see code.

Regards,

akaranta · « **Reply #13 on:** November 04, 2015, 06:44:27 AM »

Here are instructions on how to reproduce the access violation with real data in a real drawing.

I attached hatch_access_violation_sample.dwg that you can use to reproduce the problem. However, you can easily make your own:

* create a new drawing (I used acadiso.dwt template but I don't think that has any effect)
* create a rectangle
* press H and <enter> (the hatch command)
* click inside the rectangle and press <enter>

Here's the source code (can be copy-pasted to any class you have your custom AutoCAD commands in):

Code - C#: [Select]

[CommandMethod( "NSCOPYASSOCHATCH", CommandFlags.UsePickSet )]
        public static void CopyHatch() {
            var doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
            var ed = doc.Editor;
            var selPrompt = ed.SelectImplied();
            var selSet = selPrompt.Value;
            if ( selPrompt.Status != PromptStatus.OK || selSet.Count != 1 || typeof( Hatch ) != selSet.GetObjectIds()[ 0 ].ObjectClass.GetRuntimeType() ) {
                Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog( "please select a single hatch before running this command" );
                return;
            }
 
            using ( var tr = doc.TransactionManager.StartTransaction() ) {
                var originalHatch = (Hatch)tr.GetObject( selSet.GetObjectIds()[0], OpenMode.ForRead );
                if ( !originalHatch.Associative || originalHatch.HatchObjectType != HatchObjectType.HatchObject ||
                     originalHatch.NumberOfLoops == 0 || HasLoopsWithNoAssociatedObjects( originalHatch ) ) {
                    Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog( "please select an associative hatch (with only loops defined by db resident objects)" );
                    return;
                }
                CopyAssociativeHatch( ed, doc.Database, tr, originalHatch );
                tr.Commit();
            }
        }
 
        private static bool HasLoopsWithNoAssociatedObjects( Hatch h ) {
            for ( int i = 0 ; i < h.NumberOfLoops ; i++ ) {
                var associatedObjectIds = h.GetAssociatedObjectIdsAt( i );
                if ( associatedObjectIds == null || associatedObjectIds.Count == 0 ) return true;
            }
            return false;
        }
 
        private static Hatch CopyAssociativeHatch( Editor ed, Database db, Transaction tx, Hatch originalHatch ) {
            var h = new Hatch();
 
            AddEntity( tx, db, h );
 
            h.Normal = originalHatch.Normal;
            h.Origin = originalHatch.Origin;
 
            h.Associative = true;
            h.SetHatchPattern( originalHatch.PatternType, originalHatch.PatternName );
            h.PatternAngle = originalHatch.PatternAngle;
            h.PatternScale = originalHatch.PatternScale;
            h.PatternDouble = originalHatch.PatternDouble;
            h.PatternSpace = originalHatch.PatternSpace;
 
            for ( int i = 0 ; i < originalHatch.NumberOfLoops ; i++ ) {
                var loop = originalHatch.GetLoopAt( i );
                var associatedObjectIds = originalHatch.GetAssociatedObjectIdsAt( i );
                ed.WriteMessage( "copying loop of type " + loop.LoopType + "\n" );
                using ( var boundaryColl = new ObjectIdCollection( associatedObjectIds.Cast<ObjectId>().ToArray() ) ) {
                    // this call causes access violation
                    h.AppendLoop( loop.LoopType, boundaryColl );
                }
            }
 
            h.HatchStyle = originalHatch.HatchStyle;
            h.EvaluateHatch( true );
 
            return h;
        }
 
        private static ObjectId AddEntity( Transaction tx, Database db, Entity e ) {
            var btr = (BlockTableRecord)tx.GetObject( SymbolUtilityServices.GetBlockModelSpaceId( db ), OpenMode.ForWrite );
            var oid = btr.AppendEntity( e );
            e.SetDatabaseDefaults( db );
            tx.AddNewlyCreatedDBObject( e, true );
            return oid;
        }
 

This is a simplified version of what I am trying to accomplish - read state from an existing hatch object and create a new one exactly like the original. In reality the copy will be created in another process (on another computer) so I can't use Clone, autocad copy commands, clipboard etc.

To reproduce the access violation:

* select the hatch in the drawing
* type in command NSCOPYASSOCHATCH <enter>
=> access violation (in AppendLoop method)

Note that you can see in the debugger that loop.LoopType = External | Polyline | Derived

If you have problems reproducing the access violation, need more information or I have mistakenly left out something please ask.

code tags added kdub : [code = csharp]

Kerry · « **Reply #14 on:** November 04, 2015, 07:11:17 AM »

I haven't had a good look at the code , I'll do that tomorrow, I'm brain dead at the moment.
but .. are you trying to copy the id's of the associated entity(s)?? .. or perhaps does the definition of the associated hatch refer to the bounding objects ??

akaranta · « **Reply #15 on:** November 04, 2015, 07:30:14 AM »

I am not quite sure what you mean by "are you trying to copy the id's of the associated entity(s)?? .. or perhaps does the definition of the associated hatch refer to the bounding objects ??".
I am assuming that Hatch.GetAssociatedObjectIdsAt( int index ) returns the objects associated with the loop with the given index (in this case I assume the id of the rectangle is returned). In the code I just posted I am making a new ObjectIdCollection with the same object ids as in the original loop in order to create an identical hatch loop (i.e. in this case it is associated with the same object(s) as the original one).
If I haven't misunderstood completely, by definition an associative hatch refers to the bounding objects.

akaranta · « **Reply #16 on:** November 11, 2015, 02:26:43 AM »

As a workaround I changed my code so that I "strip" away the Polyline flag from the hatch loop type like so:

Code: [Select]

var ltype = ( loopType.HasFlag( HatchLoopTypes.Polyline ) && loopType != HatchLoopTypes.Polyline ) ? loopType & ~HatchLoopTypes.Polyline : loopType;

This seems to be working at least with the hatches I have tried this far and visually they look the same. I am not sure if removing the Polyline flag from the loop type like this causes any differences that are significant to a user using the drawing.

News:

Author Topic: Creating an associative hatch in C# causes access violation (Read 8019 times)

akaranta

Creating an associative hatch in C# causes access violation

Jeff H

Re: Creating an associative hatch in C# causes access violation

Bryco

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

akaranta

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

akaranta

Re: Creating an associative hatch in C# causes access violation

akaranta

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

akaranta

Re: Creating an associative hatch in C# causes access violation

Kerry

Re: Creating an associative hatch in C# causes access violation

akaranta

Re: Creating an associative hatch in C# causes access violation

akaranta

Re: Creating an associative hatch in C# causes access violation