Add block reference to model space?

[benkoshy]

Came across a discussion on the forums. Someone wants to add a block reference:

Before

BlockReference bref = new BlockReference(ptm, acBlkTbl["TestBlock"]);
acBlkTblRec.AppendEntity(bref);
acTrans.AddNewlyCreatedDBObject(bref, true);

// Add the attribute references
var blockDef = (BlockTableRecord)acTrans.GetObject(acBlkTbl["TestBlock"], OpenMode.ForRead);
foreach (ObjectId id in blockDef)
{
    if (id.ObjectClass == RXObject.GetClass(typeof(AttributeDefinition)))
    {
        var attDef = (AttributeDefinition)acTrans.GetObject(id, OpenMode.ForRead);
        if (!attDef.Constant)
        {
            var attRef = new AttributeReference();
            attRef.SetAttributeFromBlock(attDef, bref.BlockTransform);
            bref.AttributeCollection.AppendAttribute(attRef);
            acTrans.AddNewlyCreatedDBObject(attRef, true);

            if (attRef.Tag.ToUpper() == "WTYPE")
            {
                attRef.TextString = "SR23";
            }
        }
    }
}
acTrans.Commit();

After

BlockReference blockReference = blockTableRecord.NewBlockReference(point3d); 
             // create block reference
             // adds all the attribute definitions / tags
             // obviates all the boiler plate.

db.ModelSpace.Add(blockReference);	 // all done!

What if we want to amend the attribute reference(s)?

blockReference.Tags["PIPE"] = "Sewage"; 	//  Or ?!:
AttributeReference attributeReference = blockReference.Tags["PIPE"]; 
blockReference.AttributeCollections.SetValue("PIPE", "SEWAGE");  // the current way

attributeReference.Position = point3d; // alter the position

Or if we know what the tags / values on initialization, we could simply pass in a dictionary:

Dictionary<string, string> dictionaryInstance = new();
BlockReference blockReference = blockTableRecord.newReference(point3d, dictionaryInstance); 

Bad idea?

[wtertinek]

Hi Ben,

interesting topic, definitively has potential. One additional way to integrate this would be a builder, something like this:

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add(b => b.BlockReference()
               .FromBlock(acBlkTbl["TestBlock"])
               .WithPosition(point3d)
               .WithAttributeReferences());
}

This makes creating the AttributeReferences and setting the position optional.

[wtertinek]

In the polyline sample one could mix single points and point arrays:

var points = new [] { (2, 4, 0), (4, 2, 0), (6, 4, 0) };

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add(b => b.Polyline()
               .AddPoints(points)
               .AddPoint(8, 6));
}

There could be many different overloads of AddPoint and AddPoints for various data types.

[wtertinek]

So the genral pattern is:

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add(b => b.EntityType()
               .Option1(...)
               .Option2(...)
               .OptionN(...));
}

[benkoshy]

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add(b => b.Line()
               .From(x: 100, z: 100)
               .To(x: 200, z:200)); // that's great
}

I like this. With optional named parameters. It completely obviates the need for instantiating a point3d object.

The cost, with builders (as you point out) is that it requires intimate knowledge of the builder itself. If the methods are added to AutoCAD .net type, we must know how to get to it.

Perhaps it can be obviated by a common custom (prepending a builder helper, with the words 'build' )?

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add(b => b.Line()
               .BuildFrom(x: 100, z: 100)
               .BuildTo(x: 200, z:200)); // I can start by typing in Build - and Intellisense will tell me the rest.
}

// Essentially: 

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add(b => b.EntityType()
               .BuildOption1(...)
               .BuildOption2(...)
               .BuildOptionN(...));
}

Or alternatively, we can return a Builder object itself? Then you don't need to know anything, but can let intellisense tell you how to build it.

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add( new LineBuilder().From().To(1,1,1).Line ); // prepend builder methods with "build"?
}

Just tossing up ideas.

[wtertinek]

Or alternatively, we can return a Builder object itself? Then you don't need to know anything, but can let intellisense tell you how to build it.

using (var db = AcadDatabase.Active())
{
  db.ModelSpace
    .Add( new LineBuilder().From().To(1,1,1).Line ); // prepend builder methods with "build"?
}

Exactly 👍 That's the best way to do it.

[benkoshy]

public class LineBuilder
    {
        double startX = 0;
        double startY = 0;
        double startZ = 0;

        double endX = 0;
        double endY = 0;
        double endZ = 0;

        public LineBuilder From(double x = 0, double y = 0, double z = 0)
        {
            this.startX = x;
            this.startY = y;
            this.startZ = z;

            return this;
        }

        public LineBuilder To(double x = 0, double y = 0, double z = 0)
        {
            this.endX = x;
            this.endY = y;
            this.endZ = z;

            return this;
        }

        public Line Line => new Line().From(startX, startY, startZ).To(endX, endY, endZ);
    }

       // seems cumbersome
        Line line = new LineBuilder()
                        .From(1, 2, 3)
                        .To(y: 4, z: 10)
                        .Line;

   // the above is probably more complicated than this:
   new Line()
            .From(startX, startY, startZ)
            .To(endX, endY, endZ);

For the line instance, I do not think it offers much benefit over the implementation in #24. Perhaps the only benefit is developer happiness: I need to create a line --> oh how do I do that? I know, I will just use the line builder.

Your thoughts? Should a line Builder be built?

[wtertinek]

After

BlockReference blockReference = blockTableRecord.NewBlockReference(point3d); 
             // create block reference
             // adds all the attribute definitions / tags
             // obviates all the boiler plate.

db.ModelSpace.Add(blockReference);	 // all done!

I like the blockTableRecord.NewBlockReference(point3d) notation.

blockReference.Tags["PIPE"] = "Sewage"; 	//  Or ?!:
AttributeReference attributeReference = blockReference.Tags["PIPE"]; 
blockReference.AttributeCollections.SetValue("PIPE", "SEWAGE");  // the current way

attributeReference.Position = point3d; // alter the position

I'm afraid this won't work, we can't add properties like Tags to a type, only methods via extension methods. The only way to do that would be to have our own BlockReference type, which is not a good idea.

Dictionary<string, string> dictionaryInstance = new();
BlockReference blockReference = blockTableRecord.newReference(point3d, dictionaryInstance); 

In my optionion dictionaries are not a good thing for initialization because they are too unspecific. You don't know which options you have (which strings are allowed keys) without looking into documentation. No IntelliSense either.

[benkoshy]

I'm afraid this won't work, we can't add properties like Tags to a type, only methods via extension methods. The only way to do that would be to have our own BlockReference type, which is not a good idea.

I was expecting this to be available at least by c# 11, but unfortunately it is not here (perhaps i'm wrong).

In my optionion dictionaries are not a good thing for initialization because they are too unspecific. You don't know which options you have (which strings are allowed keys) without looking into documentation. No IntelliSense either.

The devil's argument to that is that: we would have to look into the documentation anyways - prior to naming a tag, or a block. We could throw an exception or simply skip the offending value, or perhaps have a dictionary builder object, to create tags / values?

BlockReference blockReference = blockTableRecord.NewReference(point3d);  // the name could be anything

// what is the current easiest way to update a list of tags with text strings?
// in the end we would essentially have to iterate through a dictionary?

[wtertinek]

I was expecting this to be available at least by c# 11, but unfortunately it is not here (perhaps i'm wrong).

AFAIK C# versions > 7.3 are no possible for .NET framework (which the AutoCAD API is based on). Did you find a way to use C# > 7.3?

The devil's argument to that is that: we would have to look into the documentation anyways - prior to naming a tag, or a block. We could throw an exception or simply skip the offending value, or perhaps have a dictionary builder object, to create tags / values?

BlockReference blockReference = blockTableRecord.NewReference(point3d);  // the name could be anything

Throwing an exception happens at runtime, preventing errors in the first place would be best. I prefer builders or an options object such cases.

[benkoshy]

You are correct (applicable versions), i was mistaken.

I have not used c# 11 on an autocad project just yet.

Throwing an exception happens at runtime, preventing errors in the first place would be best. I prefer builders or an options object such cases.

ok!

[benkoshy]

If we should limit our discussion on block references, what is your opinion of what finalised API design should be?

[wtertinek]

I'd vote for a builder solution. Would be the best way to control the object creation/configuration process.

[benkoshy]

@wtertinek Would you know if it is possible to apply the same methods and implementation to both the Line class and also to the LineBuilder class?

e.g.

Line line = new LineBuilder().From(1,2,3); 
line.To(1,2,3); // `From` method, and `To` method, being the same implementation?

[wtertinek]

In this particular case I think there is not much code to shared between Line and LineBuilder. But in general the easiest solution would be to simply create a method in a helper class that is used by Line and LineBuilder.