Effacer les couches gelées

[coyotte]

Bonjour à tous,

 

je cherche une méthode en C# qui me permettrait de supprimer toute les entités présentes sur les couches gelées de mon plan.

 

merci à tous de votre aide :cool:

[(gile)]

Salut,

 

 

Un petit truc vite fait avec une sélection filtrée des entités sur les claques gelés.

 

 

void DeleteOnFrozenLayers()
{
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
using (Transaction tr = db.TransactionManager.StartTransaction())
{
	LayerTable lt = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
	string layNames = "";
	foreach (ObjectId id in lt)
	{
		LayerTableRecord ltr = (LayerTableRecord)tr.GetObject(id, OpenMode.ForRead);
		if (ltr.IsFrozen)
		{
			ltr.IsLocked = false;
			layNames += ltr.Name + ",";
		}
	}
	TypedValue[] filter = { new TypedValue(8, layNames) };
	PromptSelectionResult psr = ed.SelectAll(new SelectionFilter(filter));
	if (psr.Status != PromptStatus.OK) return;
	foreach (SelectedObject so in psr.Value)
	{
		Entity ent = (Entity)tr.GetObject(so.ObjectId, OpenMode.ForWrite);
		ent.Erase();
	}
	tr.Commit();
}
}

[(gile)]

Ou encore, plus concis en parcourant tous les espaces.

 

Le code est écrit en F# mais on peut faire quelque chose d'équivalent en C# avec Linq

 

 

let deletOnFrozen() =
   let db = HostApplicationServices.WorkingDatabase
   use tr = db.TransactionManager.StartTransaction()
   let layNames = 
       tr.GetObject(db.LayerTableId, OpenMode.ForRead) :?> LayerTable
       |> Seq.cast
       |> Seq.map (fun id -> tr.GetObject(id, OpenMode.ForRead) :?> LayerTableRecord)
       |> Seq.choose (fun ltr -> if ltr.IsFrozen then ltr.IsLocked <- false; Some(ltr.Name) else None)
   tr.GetObject(db.BlockTableId, OpenMode.ForRead) :?> BlockTable
   |> Seq.cast<ObjectId>
   |> Seq.map(fun id -> tr.GetObject(id, OpenMode.ForRead) :?> BlockTableRecord)
   |> Seq.filter(fun btr -> btr.IsLayout)
   |> Seq.collect(fun btr -> btr
                             |> Seq.cast<ObjectId>
                             |> Seq.map(fun id -> tr.GetObject(id, OpenMode.ForRead) :?> Entity)
                             |> Seq.filter(fun ent -> layNames |> Seq.exists(fun s -> s = ent.Layer)))
   |> Seq.iter(fun ent -> ent.UpgradeOpen(); ent.Erase())
   tr.Commit()

[coyotte]

Merci a toi Gile. toujours aussi efficace ;)

[(gile)]

Merci,

 

 

La même méthode que ci-dessus écrite en C# avec Linq.

 

Linq permet d'écrire dans un style fonctionnel/déclaratif qui pourrait plaire à ceux qui viennent du LISP.

 

private void DeleteOnLockedLayers()
{
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction tr = db.TransactionManager.StartTransaction())
{
	var lockedLayers = ((LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead))
		.Cast<ObjectId>()
		.Select(id => (LayerTableRecord)tr.GetObject(id, OpenMode.ForRead))
		.Where(ltr => ltr.IsFrozen)
		.Select(ltr => { ltr.IsLocked = false; return ltr.Name; })
		.ToList();
	var ents = ((BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead))
		.Cast<ObjectId>()
		.Select(id => (BlockTableRecord)tr.GetObject(id, OpenMode.ForRead))
		.Where(btr => btr.IsLayout)
		.SelectMany(btr => btr
			.Cast<ObjectId>()
			.Select(id => (Entity)tr.GetObject(id, OpenMode.ForRead))
			.Where(ent => lockedLayers.Contains(ent.Layer)));
	foreach (var ent in ents)
	{
		ent.UpgradeOpen();
		ent.Erase();
	}
	tr.Commit();
}
}

[coyotte]

Merci Gile, cela va m’être bien utile.