string.GetHashCode获取值不一样

最新推荐文章于 2022-09-27 20:15:52 发布
转载 最新推荐文章于 2022-09-27 20:15:52 发布 · 714 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/zhaogaojian/p/9120679.html
文章标签：

#c#

本文通过实验发现String.GetHashCode值受运行环境影响，在不同计算机上保持一致，但32位和64位系统下有所不同，揭示了GetHashCode与.NET Framework版本的相关性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

今天在使用程序时发现两个String.GetHashCode值不一样，通过测试

（1）程序在两台不同的计算机上运行，没有变化。

（2）修改32位，64位，值有变化，说明GetHashCode和.netFrameWork版本有关系。

 

转载于:https://www.cnblogs.com/zhaogaojian/p/9120679.html

【unity框架开发9】序列化字典，场景，vector，color，Quaternion
向宇
10-07 1603
可读性：使数据结构更清晰，便于理解和维护。优化 Inspector：提供更友好的用户界面，方便编辑和查看数据。控制序列化：实现特定的序列化逻辑，灵活处理数据。比如在保存或加载时进行特定的转换或处理。性能提升：减少内存占用，提高序列化和反序列化的效率。易于扩展：根据项目需求灵活添加字段和功能。类型安全：确保使用正确的数据类型，减少错误。
Unity3d 周分享（15期 2019.4.14 ）
游戏路上的小学生
04-14 2919
选自过去1~2周 自己所看到外文内容：https://twitter.com/unity3d 和各种其他博客来源吧 1、 在Unity中 使用 IronPython https://qiita.com/syutotyou/items/bd9f9a74a054934277c1 环境： windows10 unity 2018.2.14f1 IronPython 2.7.9 ht...
More Effective C#——详析GetHashCode方法
aj
06-03 1035
GetHashCode函数一般是在操作HashTable或者Dictionary之类的数据集的时候被调用，目的是产生一个Key，为了方便在 HashTable或者 Dictionary中的检索。 每个类型，不管是值类型还是引用类型，都提供这个基本函数，同样也可以像重写ToString或者Equals函数一样去重写它。但是不建议重写此函数，而且在使用这个函数也需要加倍小心。...
C#中有关string.GetHashCode()的一个重要注意事项！
热门推荐
lanlicen的专栏
05-10 2万+
最近在做项目的时候，需要把字符串存入数据库，并且要求数据库中不能有重复的字符串，由此就引出了将字符串hash成特定的hash值，依靠查询hash值是否重复来判断字符串是否重复。 这样做的好处在于查询重复字符串的代价太大，因为字符串可能会非常长，进行逐个比较非常消耗数据库的性能，如果将字符串hash之后，依靠hash值来查重就显得轻便很多了，因为hash值通常都比字符串本身短很多。
C# GetHashCode在x64与x86版本下不一样
weixin_30315723的博客
02-22 203
最好指定一下目标平台 转载于:https://www.cnblogs.com/zhaogaojian/p/10417638.html
关于String重写hashCode()方法，哈希值不一样的问题
weixin_65479509的博客
09-27 378
关于String重写hashCode()方法
Object.getHashCode()之我见
u014350758的专栏
04-02 609
首先引用几段关于覆写GetHashCode的MSDN： GetHashCode函数用于快速生成一个与对象的值相对应的数字  衍生型别可以覆写GetHashCode方法。 实值型别必须覆写这个方法，以提供该型别所适用的杂凑函式，并于杂凑资料表中提供有用的散发。 杂凑函式必须具有下列属性： 如果两个物件的比较结果为相等，则各物件的GetHashCode方法就一定要传
同样的输入，为什么Objects.hash()方法返回的hash值每次不一样？
03-04 2254
目录 背景 why 最佳实践 参考资料 背景 开发过程中发现一个问题，项目中用Set保存AopMethod对象用于去重，但是发现即使往set中添加相同内容的对象，每次也能够添加成功。 AopMethod类的部分代码如下： public class AopMethod { private String methodName; private Class<?>[] parameterTypes = new Class<?>[]{}; //是否需要
using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.Colors; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.Runtime; using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Reflection; namespace ScaffoldAutomation { public class DiagonalBarPlacer { // 配置常量 private const string DiagonalBarLayer = “斜拉杆”; private const string DiagonalBarPrefix = “ScaffoldPolexie水平斜拉杆”; private const string BlockDirectoryName = “ScaffoldBlocks”; private const string AxisLayer = “盘扣轴网”; // 标准斜拉杆长度（毫米） private static readonly double[] DiagonalBarLengths = { 600, 900, 1200, 1500, 1800 }; // 缓存已存在的斜拉杆 private readonly Dictionary<string, HashSet<string>> _existingDiagonalCache = new Dictionary<string, HashSet<string>>(); // 插件目录路径 private readonly string _pluginDirectory; // 网格数据结构 private GridStructure _grid; // 容差值（毫米） private const double Tolerance = 1.0; // 1mm容差 public DiagonalBarPlacer() { _pluginDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); } [CommandMethod("BuildDiagonal", "BD", CommandFlags.Modal)] public void BuildDiagonal() { Document doc = Application.DocumentManager.MdiActiveDocument; Database db = doc.Database; Editor ed = doc.Editor; try { // 创建斜杆图层 CreateLayerIfNotExists(db, DiagonalBarLayer, 4); // 青色 CheckLayerState(db, DiagonalBarLayer); // 步骤1：选择布置模式 int mode = GetDiagonalMode(ed); if (mode == 0) return; // 步骤2：选择轴网线段 PromptSelectionOptions selOpts = new PromptSelectionOptions(); selOpts.MessageForAdding = "\n选择盘扣轴网线段: "; PromptSelectionResult selResult = ed.GetSelection(selOpts); if (selResult.Status != PromptStatus.OK) return; // 加载斜拉杆块定义 LoadDiagonalBlockDefinitions(db, ed); // 构建现有斜拉杆缓存 BuildExistingDiagonalCache(db); using (Transaction tr = db.TransactionManager.StartTransaction()) { // 处理轴网并生成网格结构 if (!ProcessAxisLines(db, selResult, tr, ed)) { ed.WriteMessage("\n无法生成有效的网格结构"); return; } // 布置斜拉杆 int diagonalCount = PlaceDiagonalBars(db, tr, mode, ed); tr.Commit(); ed.WriteMessage($"\n成功布置 {diagonalCount} 根斜拉杆"); if (diagonalCount > 0) { Application.ShowAlertDialog($"已布置 {diagonalCount} 根斜拉杆！"); } } } catch (System.Exception ex) { ed.WriteMessage($"\n错误: {ex.Message}"); } } #region 网格数据结构 // 网格结构 private class GridStructure { public List<double> XCoordinates { get; set; } = new List<double>(); public List<double> YCoordinates { get; set; } = new List<double>(); public List<GridEdge> HorizontalEdges { get; } = new List<GridEdge>(); public List<GridEdge> VerticalEdges { get; } = new List<GridEdge>(); public int RowCount => YCoordinates.Count - 1; public int ColumnCount => XCoordinates.Count - 1; } // 网格边 private class GridEdge { public Point3d StartPoint { get; set; } public Point3d EndPoint { get; set; } public double Length { get; set; } public int RowIndex { get; set; } // 行索引（水平边） public int ColIndex { get; set; } // 列索引（垂直边） public bool IsHorizontal { get; set; } public bool IsOuterEdge { get; set; } // 是否是最外侧边 public bool IsTopEdge { get; set; } // 是否是顶部边 public bool IsBottomEdge { get; set; } // 是否是底部边 public bool IsLeftEdge { get; set; } // 是否是左侧边 public bool IsRightEdge { get; set; } // 是否是右侧边 } // 点比较器（用于去重） private class Point3dComparer : IEqualityComparer<Point3d> { private readonly double _tolerance; public Point3dComparer(double tolerance) { _tolerance = tolerance; } public bool Equals(Point3d p1, Point3d p2) { return p1.DistanceTo(p2) <= _tolerance; } public int GetHashCode(Point3d p) { return (Math.Round(p.X / _tolerance), Math.Round(p.Y / _tolerance), Math.Round(p.Z / _tolerance)).GetHashCode(); } } #endregion #region 轴网处理 // 处理轴网线段 private bool ProcessAxisLines(Database db, PromptSelectionResult selResult, Transaction tr, Editor ed) { List<Line> axisLines = new List<Line>(); // 收集轴网线段 foreach (ObjectId objId in selResult.Value.GetObjectIds()) { Entity ent = tr.GetObject(objId, OpenMode.ForRead) as Entity; if (ent != null && ent.Layer == AxisLayer && ent is Line line) { axisLines.Add(line); } } if (axisLines.Count == 0) { ed.WriteMessage("\n未选择任何轴网线段"); return false; } ed.WriteMessage($"\n找到 {axisLines.Count} 条轴网线段"); // 计算所有网格交点 List<Point3d> intersections = CalculateIntersections(axisLines, ed); if (intersections.Count == 0) { ed.WriteMessage("\n未找到网格交点"); return false; } // 构建网格结构 _grid = BuildGridStructure(intersections, axisLines, ed); if (_grid == null || _grid.XCoordinates.Count < 2 || _grid.YCoordinates.Count < 2) { ed.WriteMessage("\n无法构建有效的网格结构"); return false; } ed.WriteMessage($"\n网格结构: {_grid.ColumnCount}列 x {_grid.RowCount}行"); ed.WriteMessage($"\n水平边数量: {_grid.HorizontalEdges.Count}, 垂直边数量: {_grid.VerticalEdges.Count}"); return true; } // 计算所有网格交点 private List<Point3d> CalculateIntersections(List<Line> axisLines, Editor ed) { var intersections = new HashSet<Point3d>(new Point3dComparer(Tolerance)); int totalIntersections = 0; // 计算所有线段的交点 for (int i = 0; i < axisLines.Count; i++) { for (int j = i + 1; j < axisLines.Count; j++) { Point3dCollection pts = new Point3dCollection(); axisLines[i].IntersectWith( axisLines[j], Intersect.ExtendBoth, pts, IntPtr.Zero, IntPtr.Zero ); foreach (Point3d pt in pts) { intersections.Add(RoundPoint(pt, Tolerance)); totalIntersections++; } } } ed.WriteMessage($"\n找到 {intersections.Count} 个有效网格交点（总交点: {totalIntersections}）"); return intersections.ToList(); } // 构建网格结构 private GridStructure BuildGridStructure(List<Point3d> intersections, List<Line> axisLines, Editor ed) { var grid = new GridStructure(); // 分离X和Y坐标（带容差） var xCoords = new List<double>(); var yCoords = new List<double>(); // 使用容差分组坐标 var xGroups = intersections.GroupBy(p => Math.Round(p.X / Tolerance) * Tolerance); var yGroups = intersections.GroupBy(p => Math.Round(p.Y / Tolerance) * Tolerance); // 获取排序后的坐标 xCoords = xGroups.Select(g => g.Key).OrderBy(x => x).ToList(); yCoords = yGroups.Select(g => g.Key).OrderBy(y => y).ToList(); grid.XCoordinates = xCoords; grid.YCoordinates = yCoords; // 创建水平边 for (int row = 0; row < yCoords.Count; row++) { for (int col = 0; col < xCoords.Count - 1; col++) { Point3d start = new Point3d(xCoords[col], yCoords[row], 0); Point3d end = new Point3d(xCoords[col + 1], yCoords[row], 0); // 检查是否为有效线段 if (IsValidSegment(axisLines, start, end, Tolerance)) { grid.HorizontalEdges.Add(new GridEdge { StartPoint = start, EndPoint = end, Length = start.DistanceTo(end), RowIndex = row, ColIndex = col, IsHorizontal = true, IsOuterEdge = (row == 0 || row == yCoords.Count - 1), IsTopEdge = (row == 0), IsBottomEdge = (row == yCoords.Count - 1) }); } } } // 创建垂直边 for (int col = 0; col < xCoords.Count; col++) { for (int row = 0; row < yCoords.Count - 1; row++) { Point3d start = new Point3d(xCoords[col], yCoords[row], 0); Point3d end = new Point3d(xCoords[col], yCoords[row + 1], 0); // 检查是否为有效线段 if (IsValidSegment(axisLines, start, end, Tolerance)) { grid.VerticalEdges.Add(new GridEdge { StartPoint = start, EndPoint = end, Length = start.DistanceTo(end), RowIndex = row, ColIndex = col, IsHorizontal = false, IsOuterEdge = (col == 0 || col == xCoords.Count - 1), IsLeftEdge = (col == 0), IsRightEdge = (col == xCoords.Count - 1) }); } } } return grid; } // 检查点是否在直线上（带容差） private bool IsPointOnLine(Line line, Point3d point, double tolerance) { // 检查点是否接近起点或终点 if (point.DistanceTo(line.StartPoint) <= tolerance || point.DistanceTo(line.EndPoint) <= tolerance) return true; // 计算点到直线的距离 Vector3d lineVec = line.EndPoint - line.StartPoint; Vector3d pointVec = point - line.StartPoint; // 检查点是否在线段范围内 double dotProduct = lineVec.DotProduct(pointVec); if (dotProduct < 0 || dotProduct > lineVec.LengthSqrd) return false; // 计算垂直距离 double distance = Math.Abs(lineVec.CrossProduct(pointVec).Length / lineVec.Length); return distance <= tolerance; } // 检查是否为有效线段（带容差） private bool IsValidSegment(List<Line> axisLines, Point3d start, Point3d end, double tolerance) { foreach (Line line in axisLines) { if (IsPointOnLine(line, start, tolerance) && IsPointOnLine(line, end, tolerance)) { return true; } } return false; } #endregion #region 斜拉杆布置核心逻辑（按模式实现） // 布置斜拉杆（根据不同的布置模式） private int PlaceDiagonalBars(Database db, Transaction tr, int mode, Editor ed) { BlockTableRecord btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite); BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead); if (_grid == null || (_grid.HorizontalEdges.Count == 0 && _grid.VerticalEdges.Count == 0)) { ed.WriteMessage("\n没有可用的网格边"); return 0; } int diagonalCount = 0; var placedEdges = new HashSet<string>(); // 避免重复布置 // 模式1: 隔一布一 if (mode == 1) { diagonalCount += PlacePatternOne(db, tr, btr, bt, placedEdges, ed); } // 模式2: 隔二布一 else if (mode == 2) { diagonalCount += PlacePatternTwo(db, tr, btr, bt, placedEdges, ed); } // 模式3: 隔三布一 else if (mode == 3) { diagonalCount += PlacePatternThree(db, tr, btr, bt, placedEdges, ed); } // 模式4: 满布 else if (mode == 4) { diagonalCount += PlaceFullPattern(db, tr, btr, bt, placedEdges, ed); } return diagonalCount; } // 模式1: 隔一布一 private int PlacePatternOne(Database db, Transaction tr, BlockTableRecord btr, BlockTable bt, HashSet<string> placedEdges, Editor ed) { int count = 0; // 遍历所有网格单元 for (int row = 0; row < _grid.RowCount; row++) { for (int col = 0; col < _grid.ColumnCount; col++) { // 隔一布一：行和列索引都是偶数的单元 if (row % 2 == 0 && col % 2 == 0) { count += PlaceCellEdges(row, col, btr, bt, placedEdges, db, tr, ed); } } } ed.WriteMessage($"\n隔一布一模式: 布置了 {count} 根斜拉杆"); return count; } // 模式2: 隔二布一 private int PlacePatternTwo(Database db, Transaction tr, BlockTableRecord btr, BlockTable bt, HashSet<string> placedEdges, Editor ed) { int count = 0; // 布置所有单元（隔二布一） for (int row = 0; row < _grid.RowCount; row++) { for (int col = 0; col < _grid.ColumnCount; col++) { // 隔二布一：每3个单元布置一个（行和列索引都是3的倍数） if (row % 3 == 0 && col % 3 == 0) { count += PlaceCellEdges(row, col, btr, bt, placedEdges, db, tr, ed); } } } // 布置中间垂直边（隔二布一） for (int col = 1; col < _grid.ColumnCount; col += 3) // 中间列（每3列的第2列） { for (int row = 0; row < _grid.RowCount; row++) { var edge = _grid.VerticalEdges.FirstOrDefault(e => e.ColIndex == col && e.RowIndex == row); if (edge != null) { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } } // 布置中间水平边（隔二布一） for (int row = 1; row < _grid.RowCount; row += 3) // 中间行（每3行的第2行） { for (int col = 0; col < _grid.ColumnCount; col++) { var edge = _grid.HorizontalEdges.FirstOrDefault(e => e.RowIndex == row && e.ColIndex == col); if (edge != null) { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } } ed.WriteMessage($"\n隔二布一模式: 布置了 {count} 根斜拉杆"); return count; } // 模式3: 隔三布一 private int PlacePatternThree(Database db, Transaction tr, BlockTableRecord btr, BlockTable bt, HashSet<string> placedEdges, Editor ed) { int count = 0; // 布置所有单元（隔三布一） for (int row = 0; row < _grid.RowCount; row++) { for (int col = 0; col < _grid.ColumnCount; col++) { // 隔三布一：每4个单元布置一个（行和列索引都是4的倍数） if (row % 4 == 0 && col % 4 == 0) { count += PlaceCellEdges(row, col, btr, bt, placedEdges, db, tr, ed); } } } // 布置中间垂直边（隔三布一） for (int col = 1; col < _grid.ColumnCount; col += 4) // 每4列的第2列 { for (int row = 0; row < _grid.RowCount; row++) { var edge = _grid.VerticalEdges.FirstOrDefault(e => e.ColIndex == col && e.RowIndex == row); if (edge != null) { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } } for (int col = 2; col < _grid.ColumnCount; col += 4) // 每4列的第3列 { for (int row = 0; row < _grid.RowCount; row++) { var edge = _grid.VerticalEdges.FirstOrDefault(e => e.ColIndex == col && e.RowIndex == row); if (edge != null) { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } } // 布置中间水平边（隔三布一） for (int row = 1; row < _grid.RowCount; row += 4) // 每4行的第2行 { for (int col = 0; col < _grid.ColumnCount; col++) { var edge = _grid.HorizontalEdges.FirstOrDefault(e => e.RowIndex == row && e.ColIndex == col); if (edge != null) { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } } for (int row = 2; row < _grid.RowCount; row += 4) // 每4行的第3行 { for (int col = 0; col < _grid.ColumnCount; col++) { var edge = _grid.HorizontalEdges.FirstOrDefault(e => e.RowIndex == row && e.ColIndex == col); if (edge != null) { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } } ed.WriteMessage($"\n隔三布一模式: 布置了 {count} 根斜拉杆"); return count; } // 模式4: 满布 private int PlaceFullPattern(Database db, Transaction tr, BlockTableRecord btr, BlockTable bt, HashSet<string> placedEdges, Editor ed) { int count = 0; // 布置所有水平边 foreach (GridEdge edge in _grid.HorizontalEdges) { // 最外侧边特殊处理（布置在外侧） if (edge.IsOuterEdge) { count += PlaceOuterBar(edge, btr, bt, placedEdges, db, tr, ed); } else { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } // 布置所有垂直边 foreach (GridEdge edge in _grid.VerticalEdges) { // 最外侧边特殊处理（布置在外侧） if (edge.IsOuterEdge) { count += PlaceOuterBar(edge, btr, bt, placedEdges, db, tr, ed); } else { count += PlaceSingleBar(edge, btr, bt, placedEdges, db, tr, ed); } } ed.WriteMessage($"\n满布模式: 布置了 {count} 根斜拉杆"); return count; } // 布置单个网格单元的四条边 private int PlaceCellEdges(int row, int col, BlockTableRecord btr, BlockTable bt, HashSet<string> placedEdges, Database db, Transaction tr, Editor ed) { int count = 0; // 上边 var topEdge = _grid.HorizontalEdges.FirstOrDefault(e => e.RowIndex == row && e.ColIndex == col); if (topEdge != null) { count += PlaceSingleBar(topEdge, btr, bt, placedEdges, db, tr, ed); } // 下边 var bottomEdge = _grid.HorizontalEdges.FirstOrDefault(e => e.RowIndex == row + 1 && e.ColIndex == col); if (bottomEdge != null) { count += PlaceSingleBar(bottomEdge, btr, bt, placedEdges, db, tr, ed); } // 左边 var leftEdge = _grid.VerticalEdges.FirstOrDefault(e => e.ColIndex == col && e.RowIndex == row); if (leftEdge != null) { count += PlaceSingleBar(leftEdge, btr, bt, placedEdges, db, tr, ed); } // 右边 var rightEdge = _grid.VerticalEdges.FirstOrDefault(e => e.ColIndex == col + 1 && e.RowIndex == row); if (rightEdge != null) { count += PlaceSingleBar(rightEdge, btr, bt, placedEdges, db, tr, ed); } return count; } // 布置单根斜拉杆（标准位置） private int PlaceSingleBar(GridEdge edge, BlockTableRecord btr, BlockTable bt, HashSet<string> placedEdges, Database db, Transaction tr, Editor ed) { // 生成边唯一标识 string edgeKey = $"{edge.StartPoint.X:F3},{edge.StartPoint.Y:F3}-{edge.EndPoint.X:F3},{edge.EndPoint.Y:F3}"; // 检查是否已布置 if (placedEdges.Contains(edgeKey)) { return 0; } placedEdges.Add(edgeKey); // 获取最接近的标准长度 double closestLength = GetClosestDiagonalLength(edge.Length); // 检查长度匹配精度 if (Math.Abs(closestLength - edge.Length) > Tolerance) { ed.WriteMessage($"\n警告: 线段长度 {edge.Length:F0}mm 与标准长度 {closestLength}mm 不匹配 (差值: {Math.Abs(closestLength - edge.Length):F1}mm)"); return 0; } string blockName = $"{DiagonalBarPrefix}{closestLength:0}mm"; // 计算中点位置 Point3d midPoint = new Point3d( (edge.StartPoint.X + edge.EndPoint.X) / 2, (edge.StartPoint.Y + edge.EndPoint.Y) / 2, 0); // 计算旋转角度（考虑镜像方向） double rotation = 0.0; if (edge.IsHorizontal) { // 水平边：顶部0度，底部180度 rotation = edge.IsTopEdge ? 0.0 : Math.PI; } else { // 垂直边：左侧90度，右侧270度 rotation = edge.IsLeftEdge ? Math.PI / 2 : 3 * Math.PI / 2; } // 检查是否已存在相同斜拉杆 if (IsDiagonalAlreadyExists(blockName, midPoint, rotation)) { ed.WriteMessage($"\n跳过已存在斜拉杆: {blockName} 在 ({midPoint.X:F0},{midPoint.Y:F0})"); return 0; } // 动态加载块（如果未加载） if (!bt.Has(blockName)) { if (!LoadDiagonalBlock(db, closestLength, ed)) { return 0; } bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead); } ObjectId blockId = bt[blockName]; // 创建斜杆图块引用 BlockReference br = new BlockReference(midPoint, blockId) { Layer = DiagonalBarLayer, Rotation = rotation }; // 添加到图形 btr.AppendEntity(br); tr.AddNewlyCreatedDBObject(br, true); // 添加到缓存 AddToDiagonalCache(blockName, midPoint, rotation); // 添加日志 ed.WriteMessage($"\n布置: {blockName} ({edge.Length:F0}mm) 在 ({midPoint.X:F0},{midPoint.Y:F0}), " + $"方向={(edge.IsHorizontal ? "水平" : "垂直")}, " + $"角度={rotation * 180 / Math.PI:F0}度"); return 1; } // 布置外侧斜拉杆（特殊处理） private int PlaceOuterBar(GridEdge edge, BlockTableRecord btr, BlockTable bt, HashSet<string> placedEdges, Database db, Transaction tr, Editor ed) { // 生成边唯一标识 string edgeKey = $"{edge.StartPoint.X:F3},{edge.StartPoint.Y:F3}-{edge.EndPoint.X:F3},{edge.EndPoint.Y:F3}"; // 检查是否已布置 if (placedEdges.Contains(edgeKey)) { return 0; } placedEdges.Add(edgeKey); // 获取最接近的标准长度 double closestLength = GetClosestDiagonalLength(edge.Length); // 检查长度匹配精度 if (Math.Abs(closestLength - edge.Length) > Tolerance) { ed.WriteMessage($"\n警告: 线段长度 {edge.Length:F0}mm 与标准长度 {closestLength}mm 不匹配 (差值: {Math.Abs(closestLength - edge.Length):F1}mm)"); return 0; } string blockName = $"{DiagonalBarPrefix}{closestLength:0}mm"; // 计算中点位置 Point3d midPoint = new Point3d( (edge.StartPoint.X + edge.EndPoint.X) / 2, (edge.StartPoint.Y + edge.EndPoint.Y) / 2, 0); // 计算旋转角度（考虑镜像方向） double rotation = 0.0; if (edge.IsHorizontal) { // 水平边：顶部0度，底部180度 rotation = edge.IsTopEdge ? 0.0 : Math.PI; } else { // 垂直边：左侧90度，右侧270度 rotation = edge.IsLeftEdge ? Math.PI / 2 : 3 * Math.PI / 2; } // 外侧边特殊处理：向外偏移 double offsetDistance = 50; // 向外偏移50mm Vector3d offsetDirection = Vector3d.ZAxis; if (edge.IsHorizontal) { // 上边向下偏移，下边向上偏移 offsetDirection = edge.IsTopEdge ? new Vector3d(0, -offsetDistance, 0) : new Vector3d(0, offsetDistance, 0); } else { // 左边向右偏移，右边向左偏移 offsetDirection = edge.IsLeftEdge ? new Vector3d(offsetDistance, 0, 0) : new Vector3d(-offsetDistance, 0, 0); } midPoint += offsetDirection; // 检查是否已存在相同斜拉杆 if (IsDiagonalAlreadyExists(blockName, midPoint, rotation)) { ed.WriteMessage($"\n跳过已存在斜拉杆: {blockName} 在 ({midPoint.X:F0},{midPoint.Y:F0})"); return 0; } // 动态加载块（如果未加载） if (!bt.Has(blockName)) { if (!LoadDiagonalBlock(db, closestLength, ed)) { return 0; } bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead); } ObjectId blockId = bt[blockName]; // 创建斜杆图块引用 BlockReference br = new BlockReference(midPoint, blockId) { Layer = DiagonalBarLayer, Rotation = rotation }; // 添加到图形 btr.AppendEntity(br); tr.AddNewlyCreatedDBObject(br, true); // 添加到缓存 AddToDiagonalCache(blockName, midPoint, rotation); // 添加日志 ed.WriteMessage($"\n布置外侧: {blockName} ({edge.Length:F0}mm) 在 ({midPoint.X:F0},{midPoint.Y:F0}), " + $"方向={(edge.IsHorizontal ? "水平" : "垂直")}, " + $"角度={rotation * 180 / Math.PI:F0}度"); return 1; } // 获取最接近的标准长度 private double GetClosestDiagonalLength(double segmentLength) { // 精确匹配优先 foreach (double len in DiagonalBarLengths) { if (Math.Abs(len - segmentLength) < Tolerance) return len; } // 找不到精确匹配则返回最接近的 return DiagonalBarLengths .OrderBy(len => Math.Abs(len - segmentLength)) .First(); } #endregion #region 斜拉杆缓存管理 // 构建现有斜拉杆缓存 private void BuildExistingDiagonalCache(Database db) { _existingDiagonalCache.Clear(); using (Transaction tr = db.TransactionManager.StartTransaction()) { BlockTableRecord btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForRead); foreach (ObjectId objId in btr) { BlockReference br = tr.GetObject(objId, OpenMode.ForRead) as BlockReference; if (br != null && br.Layer == DiagonalBarLayer) { string blockName = br.BlockName; Point3d roundedPos = RoundPoint(br.Position); double roundedAngle = Math.Round(br.Rotation, 4); AddToDiagonalCache(blockName, roundedPos, roundedAngle); } } tr.Commit(); } } // 添加斜拉杆到缓存 private void AddToDiagonalCache(string blockName, Point3d position, double angle) { string key = $"{position.X:F3},{position.Y:F3},{angle:F4}"; if (!_existingDiagonalCache.ContainsKey(blockName)) { _existingDiagonalCache[blockName] = new HashSet<string>(); } _existingDiagonalCache[blockName].Add(key); } // 检查斜拉杆是否已存在 private bool IsDiagonalAlreadyExists(string blockName, Point3d position, double angle) { Point3d roundedPos = RoundPoint(position); double roundedAngle = Math.Round(angle, 4); string key = $"{roundedPos.X:F3},{roundedPos.Y:F3},{roundedAngle:F4}"; return _existingDiagonalCache.ContainsKey(blockName) && _existingDiagonalCache[blockName].Contains(key); } // 四舍五入点坐标 private Point3d RoundPoint(Point3d point, double tolerance = Tolerance) { double roundFactor = 1.0 / tolerance; return new Point3d( Math.Round(point.X * roundFactor) / roundFactor, Math.Round(point.Y * roundFactor) / roundFactor, Math.Round(point.Z * roundFactor) / roundFactor); } #endregion #region 辅助方法 // 创建图层（如果不存在） private void CreateLayerIfNotExists(Database db, string layerName, int colorIndex) { using (Transaction tr = db.TransactionManager.StartTransaction()) { LayerTable lt = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead); if (!lt.Has(layerName)) { lt.UpgradeOpen(); LayerTableRecord ltr = new LayerTableRecord { Name = layerName, Color = Color.FromColorIndex(ColorMethod.ByAci, (short)colorIndex) }; lt.Add(ltr); tr.AddNewlyCreatedDBObject(ltr, true); } tr.Commit(); } } // 确保图层可见 private void CheckLayerState(Database db, string layerName) { using (Transaction tr = db.TransactionManager.StartTransaction()) { LayerTable lt = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead); if (lt.Has(layerName)) { ObjectId layerId = lt[layerName]; LayerTableRecord ltr = (LayerTableRecord)tr.GetObject(layerId, OpenMode.ForRead); if (ltr.IsFrozen || ltr.IsOff) { ltr.UpgradeOpen(); ltr.IsFrozen = false; ltr.IsOff = false; } } tr.Commit(); } } // 获取布置模式 private int GetDiagonalMode(Editor ed) { PromptKeywordOptions pko = new PromptKeywordOptions("\n选择斜拉杆布置模式: "); pko.Keywords.Add("1", "1", "1. 隔一布一"); pko.Keywords.Add("2", "2", "2. 隔二布一"); pko.Keywords.Add("3", "3", "3. 隔三布一"); pko.Keywords.Add("4", "4", "4. 满布"); pko.AllowNone = false; pko.AppendKeywordsToMessage = true; PromptResult pr = ed.GetKeywords(pko); return pr.Status == PromptStatus.OK ? int.Parse(pr.StringResult) : 0; } // 加载斜拉杆块定义 private void LoadDiagonalBlockDefinitions(Database db, Editor ed) { using (Transaction tr = db.TransactionManager.StartTransaction()) { BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead); string blockDir = GetBlockDirectory(); foreach (double len in DiagonalBarLengths) { string blockName = $"{DiagonalBarPrefix}{len:0}mm"; if (bt.Has(blockName)) continue; LoadDiagonalBlock(db, len, ed); } tr.Commit(); } } // 加载单个斜拉杆块 private bool LoadDiagonalBlock(Database db, double length, Editor ed) { string blockName = $"{DiagonalBarPrefix}{length:0}mm"; string blockPath = GetBlockFilePath(length); if (string.IsNullOrEmpty(blockPath)) { ed.WriteMessage($"\n斜拉杆块文件未找到: {blockName}"); return false; } try { using (Database sourceDb = new Database(false, true)) { sourceDb.ReadDwgFile(blockPath, FileOpenMode.OpenForReadAndAllShare, false, null); sourceDb.CloseInput(true); using (Transaction tr = db.TransactionManager.StartTransaction()) { BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForWrite); if (!bt.Has(blockName)) { db.Insert(blockName, sourceDb, true); ed.WriteMessage($"\n已加载斜拉杆块: {blockName}"); } tr.Commit(); } } return true; } catch (System.Exception ex) { ed.WriteMessage($"\n加载块 {blockName} 时出错: {ex.Message}"); return false; } } // 获取块文件目录 private string GetBlockDirectory() { string scaffoldBlocksDir = Path.Combine(_pluginDirectory, BlockDirectoryName); if (!Directory.Exists(scaffoldBlocksDir)) { try { Directory.CreateDirectory(scaffoldBlocksDir); } catch { return _pluginDirectory; } } return scaffoldBlocksDir; } // 获取块文件路径 private string GetBlockFilePath(double length) { string blockName = $"{DiagonalBarPrefix}{length:0}mm"; string blockDir = GetBlockDirectory(); string[] extensions = { ".dwg", ".DWG", ".dxf", ".DXF" }; foreach (string ext in extensions) { string path = Path.Combine(blockDir, $"{blockName}{ext}"); if (File.Exists(path)) return path; } return null; } #endregion } } CAD运行测试中y以下问题依然存在： 隔二布一：水平方向隔二的两跨内中间垂直线未布置斜拉杆，而在水平方向隔二的两跨上水平线上布置了两根斜拉杆，垂直方向隔二的两跨内中间水平线未布置斜拉杆，而在垂直方向隔二的两跨右侧垂直线上布置了两根斜拉杆 隔三布一：水平方向隔三的三跨内中间垂直线未布置斜拉杆，而在水平方向隔三的三跨上水平线上布置了三根斜拉杆，垂直方向隔三的三跨内中间两根水平线未布置斜拉杆，而在垂直方向隔三的三跨右侧垂直线上布置了三根斜拉杆 斜拉杆还是匹配错误900mm的线段长布置了600mm的斜拉杆 四条边布置的斜拉杆有两条边布置斜拉杆方向错误，四条边底部和右侧斜拉杆要以线段的镜像布置已改对了，但左侧和上面的反而改错了 将代码中问题修改成完整的一套代码
最新发布
07-11
但这样调整后，顶部边和底部边就一样了（都是180度），左侧边和右侧边也一样了（都是270度）。这显然不对，因为顶部和底部应该对称，左侧和右侧应该对称。 所以，问题可能在于块定义的方向。我们可能需要两种块：...
private void InsertData(object sender, ElapsedEventArgs e) { try { using (var conn = new MySqlConnection(connectionString)) { conn.Open(); // 生成随机数据 var data = new { DateTime = DateTime.Now, AnalysisPerTon = Math.Round(random.NextDouble() * 10, 2), UraniumContent = Math.Round(random.NextDouble() * 5, 2), TotalCount = Math.Round(random.NextDouble() * 100, 2) }; // 插入所有表 string[] tables = { "minute", "instantaneous", "daily", "shiftview", "rolling" }; foreach (var table in tables) { string sql = $@" INSERT INTO {table} (DateTime, AnalysisPerTon, UraniumContent, TotalCount) VALUES (@dt, @apt, @uc, @tc)"; using (var cmd = new MySqlCommand(sql, conn)) { cmd.Parameters.AddWithValue("@dt", data.DateTime); cmd.Parameters.AddWithValue("@apt", data.AnalysisPerTon); cmd.Parameters.AddWithValue("@uc", data.UraniumContent); cmd.Parameters.AddWithValue("@tc", data.TotalCount); cmd.ExecuteNonQuery(); } } // 更新UI Dispatcher.Invoke(() => { }); } } catch (Exception ex) { Dispatcher.Invoke(() => MessageBox.Show($"数据插入失败: {ex.Message}")); } }将这个方法每一个表生成的随机数不一样
06-21
- 使用表名或唯一标识符生成种子值（如 `表名.GetHashCode()`） - 确保不同表的种子不同，从而产生独立的随机序列 2. **批量生成数据时使用事务** - 提高插入效率，避免逐条提交的开销 - 使用 `SqlBulkCopy` 或...
String 比较以及hashcode 总结
javawar8的博客
06-28 515
  关于“==”         Java中当“==”匹配时，其实就是比较两个内存单元的内容是否一样。 如果是原始类型如byte、short、boolean、int等，就是直接比较它们的值，这个大家应该都懂。 如果是引用，比较的就是引用的值。即比较两个对象的地址是否一样，换句话说，如果两个引用所保存的对象是同一对象，则认为它们相等，否则返回false。   关于equals() ...
Java中string中hashcode_hashCode（）在Javastring上的一致性
weixin_39700394的博客
03-01 418
hashCode()在Javastring上的一致性Java String的hashCode值计算为( String.hashCode() )：s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]有什么情况下(如JVM版本，供应商等)下面的expression式将评估为false？boolean expression = "This is a Java stri...
Java得到值相同但hashcode不同的字符串的原因
qq_37019546的博客
04-02 4341
这个问题是我在leetcode上刷题遇到的，用HashSet存放string对象，结果值完全相同的string对象也存放进去了！我debug一看，原来是hashcode不同。当时我一度以为是我字符串拼接的方式不对（的确也是），结果试了好久也没发现问题～ 先上leetcode翻译原题 929.Unique Email Addresses 每封电子邮件都包含本地名称和域名，以@符号分隔。例如...
String.GetHashCode() 用法 返回INT唯一值
weixin_30312563的博客
12-12 513
给实现者的说明 哈希函数用于快速生成一个与对象的值相对应的数字（哈希代码）。哈希函数通常是特定于每个 Type 的，而且，必须至少使用一个实例字段作为输入。 哈希函数必须具有以下特点： 如果两个类型相同的对象表示相同的值，则哈希函数必须为两个对象返回相同的常数值。 为了获得最佳性能，哈希函数必须为所有输入生成随机分布。 不论对该对象进行什么样的更改，哈希函数都必须返回完全相...
值类型和引用类型在hashtable里面性能比较分析1 -GetHashCode()
weixin_33713350的博客
01-08 143
上篇文章中，测试了一下值类型数据和引用类型数据在hashtable中插入和读取的性能，测试结果和本人预期也有一些出入，msdn有一篇文章介绍在box,unbox的时候，性能关系为:class&gt;interface&gt;int,原文：Open the Box! Quick，进一步分析了上篇测试，发现其实影响测试性能还有其它几个方面的因素，本篇就针对不同数据类型在GetHashCode()上面的...
GetHashCode
weixin_30306905的博客
05-02 151
现引用MSDN中的几段话： GetHashCode 方法适用于哈希算法和诸如哈希表之类的数据结构。 GetHashCode 方法的默认实现不保证针对不同的对象返回唯一值。而且，.NET Framework 不保证 GetHashCode 方法的默认实现以及它所返回的值在不同版本的 .NET Framework 中是相同的。因此，在进行哈希运算时，该方法的默认实现不得用作唯一对象标识符。 ...
c#中关于gethashcode()的一点看法
wickiup的专栏
03-24 2344
GetHashCode()具有很特殊的要求：相等的对象必须产生相等的散列值，并且散列值必须是对象不变的，并且是均衡的高效分布。所有这些只有对恒定类型才能满足。这句话摘自:Effective C#中。关于gethashcode方法，重写时应该遵守以上三个准则。我看了下，要想同时做到准确和高效是很难的。准则一和二要求，产生的散列值依赖于对象，无论对象的属性等如何变化，只要它还是这个对象，他
C# GetHashCode 的实现方式
我的英文站点：https://iorilan.medium.com/
12-09 6130
C# GetHashCode 的实现方式
Object.GetHashCode 如何重载
10-12
`Object.GetHashCode()` 是.NET框架中的一个默认实现，它通常返回对象的内存地址，这样的哈希值对于大多数情况来说是不可预测的，不利于散列表操作。如果你想为特定类型的对象提供更合适的哈希值，可以在自定义类中重写 `GetHashCode()` 方法。 重载 `GetHashCode()` 的基本规则包括： 1. **一致性**：如果两个对象被认为是相等的（`Equals(object obj)` 返回 `true`），那么它们的哈希码也应该是相等的（或至少非常接近）。不相等的对象应该有不同的哈希码，以减少哈希冲突的概率。 2. **稳定性**：如果对象的状态不变，其哈希码也应该保持不变，这对于动态数据结构很重要。 3. **高效**：理想情况下，哈希码计算应快速且尽可能均匀分布，以便散列表操作的效率。 示例代码（在 C# 中）： ```csharp public override int GetHashCode() { // 使用多个字段的组合计算哈希，这里仅做演示 unchecked { int hash = 17; hash = hash * 23 + Name.GetHashCode(); // 如果Name字段重要，就先计算它的哈希 hash = hash * 23 + Age.GetHashCode(); // 添加更多字段... return hash; } } ``` 记得同时也要重写 `Equals(object obj)` 方法，使得这两个方法之间保持一致的行为，即满足“如果 x.Equals(y) 那么 x.GetHashCode() == y.GetHashCode()`。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值