如您所知，在向集合中添加新对时Dictionary，首先计算密钥的哈希值。然后对该 hash 执行按位运算& 0x7FFFFFFF，如集合的源代码中所示。
我有一个问题，如果我对所有内容都理解正确，那么只有在哈希结果为负数的情况下才需要此操作，因为我们int也可以存储负值。而这个操作的结果是另一个数字，它总是正数。
如果是这种情况，那么代替：
int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
int targetBucket = hashCode % buckets.Length;
你可以使用这样的代码：
int hashCode = comparer.GetHashCode(key);
if (hashCode < 0)
{
hashCode = hashCode * -1;
}
int targetBucket = hashCode % buckets.Length;
正确的？
这是提交历史：
iss1Anton从那里创建了一个分支master并进行了两次提交4和5。反过来，Vadim 决定开始自己的工作，从提交4中获取 Anton 的一些工作。Vadim 提交6并将他的分支合并iss2到master：
安东不知道有人一直在弹他的树枝。一天过去了，在继续开发该功能之前，Anton 决定在masterrebase 的帮助下进行新的更改。
我是否正确理解这是 Anton 无法重新定位的情况master之一，因为他的提交4之一已经进入了一般分支master？
我应该注意到，在 Anton 计划做 rebase 的那一刻，Vadim 已经完成了他的合并，即提交4的更改已经在master.
我同意下面的回答者的观点，从技术上讲，rebase 可以完成，甚至可以在没有冲突的情况下完成。问题是这里是否违反了“你不应该改变总分支”的黄金法则？
我正在开发一个用于使用模式的库，其中域逻辑如下：
如果将使用我的库的开发人员尝试访问表 ( Scheme.Table.Rows) 并且架构没有表，那么NullReferenceException我希望抛出一个更容易理解的错误，而不是 。并决定实施该模式Null Object。
现在这是通过界面完成的，这就是它在项目中的外观：
public class Scheme
{
public ITable Table { get; }
public IPicture Picture { get; }
/// <summary>
/// Creates a new <see cref="Scheme"/> instance with table content.
/// </summary>
public Scheme(ITable table)
{
Table = table;
Picture = new NoPicture();
}
/// <summary>
/// Creates a new <see cref="Scheme"/> instance with picture content.
/// </summary>
public Scheme(IPicture picture)
{
Table = new NoTable();
Picture = picture;
}
}
public interface ITable
{
IEnumerable<Row> Rows { get; }
}
public class Table : ITable
{
public IEnumerable<Row> Rows { get; }
}
public class NoTable : ITable
{
public IEnumerable<Row> Rows => throw new Exception("Scheme does not contain a table.");
}
public interface IPicture
{
Image Image { get; }
}
public class Picture : IPicture
{
public Image Image { get; }
}
public class NoPicture : IPicture
{
public Image Image => throw new Exception("Scheme does not contain a picture.");
}
下面是它在抽象类上的样子：
public class Scheme
{
public AbstractTable Table { get; }
public AbstractPicture Picture { get; }
/// <summary>
/// Creates a new <see cref="Scheme"/> instance with table content.
/// </summary>
public Scheme(AbstractTable table)
{
Table = table;
Picture = new NoPicture();
}
/// <summary>
/// Creates a new <see cref="Scheme"/> instance with picture content.
/// </summary>
public Scheme(AbstractPicture picture)
{
Table = new NoTable();
Picture = picture;
}
}
public abstract class AbstractTable
{
public abstract IEnumerable<Row> Rows { get; }
}
public class Table : AbstractTable
{
public override IEnumerable<Row> Rows { get; }
}
public class NoTable : AbstractTable
{
public override IEnumerable<Row> Rows => throw new Exception("Scheme does not contain a table.");
}
public abstract class AbstractPicture
{
public abstract Image Image { get; }
}
public class Picture : AbstractPicture
{
public override Image Image { get; }
}
public class NoPicture : AbstractPicture
{
public override Image Image => throw new Exception("Scheme does not contain a picture.");
}
这是可以使用接口或抽象类实现相同事物的另一种情况。但从逻辑和设计的角度来看，哪个更正确？
我通常使用抽象类将公共代码放在单独的位置，最重要的是，实体之间的关系是IS类型，但我发现很难说它是NoTabel什么AbstractTable。
在 Wikipedia 上阅读有关打包/拆包的信息，
将引用类型拆箱为值意味着必须显式完成此操作。在这种情况下，首先必须确保被引用的装箱对象的类型与原来的类型相对应，其次，将装箱对象的数据字段复制到该类型的新变量中。通常，类型检查是使用生成和处理异常的机制进行的，然后复制将对象的内部数据（字段）从“堆”传输到正在运行的应用程序的堆栈，其中存储了其局部变量. 具体操作的顺序简化为以下步骤：
如果指向装箱值类型的服务指针为空，则抛出 NullReferenceException，
如果装箱对象与所需类型不匹配，则会引发 InvalidCastException。
我遇到了他们在这里说的话：
1. 如果指向装箱值类型的服务指针为空，则抛出 NullReferenceException。
我是否正确理解“指向打包值类型的服务指针”应该理解“指向类型对象（TypeObjectPointer）的指针”？如果我是对的，TypeObjectPointer 可以为空吗？
public class Shape
{
public int X { get; set; }
public int Y { get; set; }
public int Width { get; set; }
public int Height { get; set; }
}
public class ShapeRender
{
public void Render()
{
var shapes = new List<Shape>
{
new Shape
{
X = 2530,
Y = 2041,
Width = 1890,
Height = 621
},
new Shape
{
X = 6516,
Y = 1944,
Width = 1890,
Height = 816
}
};
// Code to draw shapes and save into image file.
//...
}
}
在上面的代码中，在方法ShapeRender()中，创建Shape了需要在这样一个平面上绘制的对象：
并将生成的图像保存为 jpg、png 或 bmp 文件。
为属性X、Y、Width、 设置的单位是Height有条件的。
使用哪个 .NET 工具包？我在命名空间中翻了很多遍System.Drawing，但我无法整理出来。
我试图了解集合ConcurrentBag<T>和List<T>本文之间的区别。
出于某种原因，在我看来，如果我使用List<T>它并且当一个线程在那里写一些东西并尝试对另一个线程做同样的事情时，会弹出一个异常，但不，一切正常。
有一种多线程处理场景，在其工作结束时，所有线程必须将其结果写入一个集合：
class Program
{
static void Main(string[] args)
{
var results = new List<string>();
//var results = new ConcurrentBag<string>();
// STEP 1: Get results.
Parallel.For(1, 50000, idx =>
{
// Some process.
//...
results.Add("something");
});
// STEP 2: Process results.
foreach (var result in results)
{
//...
}
}
}
ConcurrentBag<T>我在用例中而不是List<T>在我的案例中获得什么优势？
还有一个小问题：results称它为共享资源是否正确？
有格式的文本文件scheme{N}.txt，其中包含格式中的行：
x – значение координаты X,
y – значение координаты Y,
w – ширина элемента,
y – высота элемента,
type – тип элемента (1-прямоугольник, 2-круг)
描述位于图表上的元素。一个文件 - 一个方案，一行 - 一个元素。
例如，有两种方案：
使用您的文本文件：
方案1.txt
200,200,400,100,1
1100,200,400,100,1
700,450,350,200,2
方案2.txt
200,200,400,200,1
1100,200,400,200,1
700,300,350,150,2
350,550,950,100,1
当然，这样的文件有数百个，现在有必要使用聚类对这些方案进行分组，在一组中会有元素布局和空间排列scheme{N}.txt最相似的方案（文件名）。例如，上述两种方案可以被认为是相似的，因此被定义在一组中。
根据任务，如何为聚类准备数据？明明这是 ML，不可能有明确的推荐，但不知道从何说起。如果您在指示性描述的帮助下尝试，因为事实证明模式对象（训练样本）必须由一组元素对象来描述。请告诉我应该寻找解决方案的方向。
作为一名 .NET 开发人员，我仍然计划使用 .NET 的 ML 框架之一来实现整个事情：ML.NET，它现在正在开发中，但是集群已经允许或Accord.NET Framework，同志由于它的年龄，它的 API 最丰富。
现在我正在阅读这篇文章C# 中缓冲区和流之间的区别，我想首先了解一下，我正确理解了执行指令时引擎盖下发生的情况FileStream stream = new FileStream("filepath.txt", FileMode.open)。
HDD/SSD 上有一个文件filepath.txt可能比 RAM 还要大。并且在执行上述指令时，运行时环境就像是在这个文件的开头带来了一个软管并打开了水龙头。Vodichka（字节）不会立即流动，而只是准备就绪。
我是否正确描述了一切？
有一篇很好的文章-答案，当你需要刷新一些理解并行计算的点时，大概可以作为一种参考。这篇关于异步编程的文章说
异步是指操作可以由旁边的人执行...
基于此，我可以理解 和 之间的区别DbSet<T>.Save()，DbSet<T>.SaveAsync()即：当我们保存到外部源（例如，数据库）时，需要等待响应，而等待的时间不取决于我们的代码，那么最好使用此方法的异步版本来释放线程以满足其他需求，然后当答案到来时，继续处理该线程或另一个线程已经回答的问题。
那么异步选项AddAsync()呢，出于某种原因需要它，为什么要等待答案，加法不是发生在内存中，还是我知道一些特殊情况？
有一个代码：
class Program
{
static void Main(string[] args)
{
string text = "My name is Adam";
text = Regex.Replace(text, @"[^\s]", "x");
Console.WriteLine(text);
Console.ReadKey();
}
}
其中所有字符都替换为x一个小字符，除了所有空白和非空白字符，包括换行符(\s)。
结果："xx xxxx xx xxxx"
我尝试了各种选择，现在我无法保留角色的大小写，即 把小写字母改成小写字母，把大写字母改成x大写X字母。例如：
使这个："My name is Adam"成为这个："Xx xxxx xx Xxxx"
我需要获取组形状(Group 37)中形状的绝对X坐标。(Freeform 39)
我做这样的计算
4637017 (GroupShape X) + 5863712 (target ChildShape) = 10500729
但计算不正确，因为 在我用这样的X坐标(10500729)放置一个单独的图形后，我看到了不同之处。
如何从组形状中正确计算形状的绝对X坐标？
不幸的是，对параллельного编程的理解和многопоточности对其他许多人一样，只有经验才能让我明白。执行某种算法来处理 200 张幻灯片的 PowerPoint 演示文稿，Диспетчер задач - Производительность我看到我的处理器平均加载了 30-35%。
我决定做并行处理。我复制了这个文件两次，以便可以由三个线程完成处理，每个线程都将执行其部分：文件副本中的第一个线程处理 1-50 张幻灯片，第二个线程处理 51-100 张幻灯片，第三个线程处理 101- 200 张幻灯片。
public void ProccessPptx()
{
Task task1 = Task.Run(() =>
{
string presentationPath1 = @"c:\temp200_1.pptx";
// proccess 1-50 slides
});
Task task2 = Task.Run(() =>
{
string presentationPath2 = @"c:\temp200_2.pptx";
// proccess 51-100 slides
});
string presentationPath3 = @"c:\temp200_3.pptx";
// proccess 101-200 slides
task1.Wait();
task2.Wait();
}
性能提升：单线程处理耗时 45 秒，使用上述并行处理耗时 25 秒。处理器负载也增加了：平均保持在 60-70%，也就是说，资源的使用效率更高。
我有以下Диспетчер задач - Производительность图片
我理解正确，无论你如何扭曲它，无论我创建多少线程，都只会并行执行8个线程，如果它们的数量超过8个，那么它们将被多线程执行，即 什么时候处理器会交替地从一个跳到另一个？
我需要解析一个PowerPoint演示文稿（.pptx）的幻灯片，即为幻灯片上的每个元素（形状）获取三个值：
你需要使用其他工具Microsoft.Office.Interop.PowerPoint，以免依赖预装Microsoft PowerPoint。
假设幻灯片。是的，当然，Google 搜索和第一行显示的前 20 个 NuGet PowerPoint 包Aspose.Slides。它非常适合我们的需求，但非常昂贵：Aspose 的人说，在销售基于它的产品时，有必要为团队中的每个开发人员购买开发人员 OEM 许可证。这样一份许可证的价格为 2397 美元。
打开 XML。我被警告过，Open XML曲线，但灵活。但没想到曲线这么多，直觉上难以理解。
我以某种方式想出了如何获取幻灯片上元素的坐标
using (PresentationDocument doc = PresentationDocument.Open(@"d:\test.pptx", false))
{
Slide firstSlide = doc.PresentationPart.SlideParts.First().Slide;
CommonSlideData csd = firstSlide.GetFirstChild<CommonSlideData>();
var shapes = csd.Descendants<Shape>();
foreach (var shape in shapes)
{
var t2d = shape.ShapeProperties.Transform2D;
if (t2d != null)
{
Console.WriteLine($"X: {t2d.Offset.X}\nY: {t2d.Offset.Y}");
}
}
}
但我不知道如何找出对象的类型。在 Interop 中很容易获得这种类型：每个 Shape 都有一个 Type 属性，而 Open XML 将它隐藏在哪里是未知的。
1) 我提出身份验证请求
login(username: string, password: string) {
console.log(this.apiUrl);
return this.httpClient.post<any>(this.apiUrl, { UserName: 'someUser', Password: 'somePassword' }, { withCredentials: true } )
.map(() => {
localStorage.setItem('loggedIn', 'true');
});
}
2）服务器在响应中发送一个cookie.AspNet.Session用于保存。我检查：Chromecookies 已保存：
3）现在当我提出其他这样的要求时
getUsers() {
return this.httpClient.get<User[]>(this.apiUrl, { withCredentials: true });
}
4) 我收到 401 错误。很明显，这是因为我Chrome没有将必要的 cookie 附加到请求中.AspNet.Session
但是 Firefox 附加了 cookie，因此请求是成功的。会是什么呢？
在此之前，我必须使用Open XMLExcel，即其 ClosedXML 包装器。现在，已经在处理文件PowerPoint，我需要获取幻灯片上对象的坐标。对于初学者来说，Shape我什至无法到达/到达对象本身，而对我来说足够的最大值就是这个
PresentationPart presentationPart;
using (PresentationDocument doc = PresentationDocument.Open(@"d:\test.pptx", false))
{
presentationPart = doc.PresentationPart;
var element = presentationPart.SlideParts.First().Slide.CommonSlideData.ShapeTree.First();
}
我想现在我将按下“点” element.，我将能够得到我需要的一切），但它不在那里：甚至没有坐标的提示。一切都隐藏在哪里，我如何获得对象的坐标x和y？
我们是一家初创公司，我们仍在积极招募志同道合的人，但我们的产品即将试行。我们的软件由以下模块组成：
任务是组织一个策略，以便在客户的基础设施上轻松部署所有三个节点，当然要考虑到将编写安装教程以及客户的技术服务将参与安装的事实。
将在客户端服务器上运行的操作系统是未知的，我想制作一个适用于 Windows 和 Linux 的通用安装过程。很明显，您必须为多功能性付费。
正如我在上面所写的，我们只是一个发展中的小队，我们仍然没有一个优秀的管理员专家，在解决军火库中的此类部署任务方面拥有丰富的经验。
码头工人。码头工人，码头工人和更多码头工人。自然，首先，程序员会想到这个软件的任务之一（我说过其中之一），即使程序员免于部署问题并让他尽可能地专注于编码。哦，要是这样就好了。
代理服务器。不管怎么说，Apache、IIS、nginx 等服务器之一是 Kestrel/HTTP.sys 的优势。据我了解，仍然需要。即使客户计划仅在公司网络内使用我们的产品。当然，使用 HTTP.sys 会更好：它不像 Kestrel 那样赤裸裸，但我们正在谈论通用性，并且 HTTP.sys 仅适用于 Windows。例如，我尝试在Windows Server上安装nginx作为实验：我的妈妈是亲爱的，从外面看起来我是第一次看到一台电脑）。
如果可以的话，我想问两个问题：
1）第一个问题比较笼统，你可能猜到了：你推荐什么？
2）现在，具体来说：我目前正在使用 Windows 10，如果我决定使用 Docker，那么我正确理解我需要创建四个容器
这可以直接从 Windows 完成吗？也就是说，在 Windows 机器上创建的容器可以在 Linux 上运行吗？
我刚开始学习NumPy。我想澄清一下：
b = np.array([[1.5, 2, 3], [4, 5, 6]])
它是在创建一个二维数组，其中 b[0][0] = 1.5，b[1][0] = 4，等等？
进行测量以找出哪个集合创建和迭代更快IOrderedEnumerable<T>或SortedSet<T>
internal class User
{
public string Surname { get; set; }
public string Name { get; set; }
public int DocumNumber { get; set; }
}
internal class UserDto : IComparable<UserDto>
{
public string FullName { get; set; }
public int DocumNumber { get; set; }
public int CompareTo(UserDto other)
{
return string.Compare(this.FullName, other.FullName, StringComparison.Ordinal);
}
}
class Program
{
static void Main(string[] args)
{
const int count = 1000000;
var users = new List<User>();
for (var i = 0; i < count; i++)
{
users.Add(new User
{
Name = "Name",
Surname = "Surname",
DocumNumber = i
});
}
// IOrderedEnumerable<T>
var watch = Stopwatch.StartNew();
var userDtoList = new List<UserDto>();
foreach (var user in users)
{
userDtoList.Add(new UserDto
{
FullName = $"{user.Surname} {user.Name}",
DocumNumber = user.DocumNumber
});
}
var orderedEnumerableUserDto = userDtoList.OrderBy(u => u.FullName);
foreach (var userDto in orderedEnumerableUserDto)
{
// просто делаем некую работу
}
watch.Stop();
Console.WriteLine("IOrderedEnumerable<T>: {0}ms", watch.ElapsedMilliseconds);
// SortedSet<T>
watch.Restart();
var sortedSetUserDto = new SortedSet<UserDto>();
foreach (var user in users)
{
sortedSetUserDto.Add(new UserDto
{
FullName = $"{user.Surname} {user.Name}",
DocumNumber = user.DocumNumber
});
}
foreach (var userDto in sortedSetUserDto)
{
// просто делаем некую работу
}
watch.Stop();
Console.WriteLine("SortedSet<T>: {0}ms", watch.ElapsedMilliseconds);
System.Console.ReadKey();
}
}
根据三个测量的结果，平均值如下：
IOrderedEnumerable<T>: 4661 ms
SortedSet<T>: 611 ms
快了近 8 倍SortedSet<T>。
在帖子的开头，我称它为IOrderedEnumerable<T>集合。我知道我错了，对不起，我只是不知道在比较集合和界面时如何正确操作。
我不明白这个接口是如何工作的，它返回什么样的枚举器。因为如果我们从两个测量中删除块
foreach (var userDto in orderedEnumerableUserDto)
{
// просто делаем некую работу
}
我们将看到测量显示相同的结果。我确定表达式
var orderedEnumerableUserDto = userDtoList.OrderBy(u => u.FullName);
不会在内存中进行任何排序，否则会花费很多时间。在那里，很可能只发生了对象的标记——枚举器接口将调用哪个队列中的谁IOrderedEnumerable，例如
我提出了我的想法IOrderedEnumerable<T>，因为我想说如果我从内部理解它是如何工作的，那么也许这个问题就不会出现。好吧，问题是：这两个选项中的哪一个更好地返回给控制器，这将在 JSON 中序列化所有这些优点，这会更快地发生吗？
我不够聪明，无法测量这两个对象的序列化速度，如果将这样的测量显示为答案，我将不胜感激。
例如，如何阅读响应的标题Content-Type？我无法做到这一点。我正在尝试至少显示所有标题
import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';
import { CookieService } from 'ngx-cookie-service';
@Injectable()
export class AuthService {
readonly endpoint = 'http://xxx.xxx.xxx.xxx:8081/login/';
phpsessidCookieValue = '';
constructor(private readonly httpClient: HttpClient,
private readonly cookieService: CookieService) { }
post(userName: string, password: string) {
const body = new HttpParams()
.set('username', userName)
.set('password', password);
const headers = new HttpHeaders()
.append('Content-Type', 'application/x-www-form-urlencoded');
const options = {
headers: headers
};
return this.httpClient.post(this.endpoint, body, options)
.subscribe((response: HttpResponse<any>) => {
console.log(response.headers); /*undefined*/
});
}
}
，但控制台告诉我 response.headers = undefined。在浏览器中你可以看到一切都是错误的
我正在设计一个用于测试的服务域区域。不同类别的参与者将参加各种测试：学校的学生，学校的老师和学校的前学生，该学校的前学生。需要注意的是，在测试的时候，学校以前的学生一般都附在学校里，他没有课（他已经没学了）。
您经常可以在网上看到这样的说法，即您应该尽可能使用组合而不是继承。但是还有另一个我更同意的说法：您只需要了解这两种关系中的哪一种存在is （继承）或has （组合/聚合）。
这是我的课程：
/// <summary>
/// При тестировании бывших учеников школы, используются объекты данного класса
/// </summary>
public class SchoolParticip
{
public string Surname { get; set; }
public string Name { get; set; }
public DateTime Birthday { get; set; }
/// <summary>
/// Ходил ли участник в садик до поступления в школу?
/// </summary>
public bool WentKindergarten { get; set; }
public School School { get; set; }
public DateTime AddedDate { get; set; }
public string DataSourceName { get; set; }
}
/// <summary>
/// Ученик школы
/// </summary>
public class ClassParticip : SchoolParticip
{
/// <summary>
/// Класс в школе
/// </summary>
/// <example>1А | 3Б и т.п.</example>
/// <remarks>Class - это отдельный класс</remarks>
public Class Class { get; set; }
}
/// <summary>
/// Учитель школы
/// </summary>
/// <remarks>
/// Объекты данного класса используются, когда проходит какое-то тестирование учителей,
/// которые также закреплены за определенными школами.
/// </remarks>
public class TeachParticip : SchoolParticip
{
/// <summary>
/// Стаж работы
/// </summary>
public int Experience { get; set; }
/// <summary>
/// Категория
/// </summary>
/// <remarks>
/// Класс Category описывает категории (первая категория, высшая категория и т.д.).
/// </remarks>
public Category Category { get; set; }
}
整个问题是这样的：
1. 我是否做了正确的事情，主要从概念的角度来看，我在这里选择了继承，而不是组合？
子问题是：
1.1）这些实体将被投影到关系数据库表上，我需要字段AddedDate- 添加记录的时间和DataSourceName- 数据源的名称（通过 LC 添加时，这将是登录名）。但是从概念的角度来看，说“我是测试参与者并且我有属性“TimeAddingMeToDatabase””是否正确？除非可以将类似的属性放在一行中，例如姓氏和名字。也许这里需要某种模式？我缺乏什么设计知识？