小编Tim*_*lds的帖子

请考虑以下代码.

static class X
{
    public static int Value = Task.Run(() => 0).Result;
}

class Program
{
    static void Main(string[] args)
    {
        var value = X.Value;
    }
}

调用Task.Run然后Result在静态初始化程序中导致程序永久冻结.为什么？

我正在尝试编写一个为分区Panel生成绘图的应用程序.

我有N个小隔间(2D矩形)(N <= 40).对于每个隔间,存在最小高度(minHeight [i])和最小宽度(minWidth [i]).面板本身也有一个MAXIMUM_HEIGHT约束.

这些N小室必须以列方式网格排列,以便满足每个小隔间的上述限制.

此外,每列的宽度由该列中每个隔间的最大minWidth决定.

此外,每列的高度应相同.这决定了面板的高度

我们可以在任何列的左侧空白处添加备用隔间,或者我们可以将任何隔间的高度/宽度增加到指定的最小值以外.但是我们不能旋转任何小隔间.

OBJECTIVE: TO MINIMIZE TOTAL PANEL WIDTH.

目前我只是通过忽略优化中的小隔间宽度来实现它.我只选择具有最大minHeight的隔间并尝试将其放入我的面板中.但是,它并不保证最佳解决方案.

我能比这更好吗？

编辑1:面板的MAXIMUM_HEIGHT = 2100mm,最小宽度范围(350mm至800mm),最小高度范围(225mm至2100mm)

编辑2:问题目标:最小化面板宽度(不是面板区域).

我有大约4000篇博文.我想根据以下值对所有帖子进行排名

Upvote Count => P
Comments Recieved => C
Share Count => S
Created time in Epoch => E
Follower Count of Category which post belongs to => F (one post has one category)
User Weight => U (User with most number of post have biggest weight)

我期待在伪代码中回答.

我的妻子给了我这个任务,所以这是头等大事:-)

我有一系列积分(实际上是Northings和Eastings,但这并不重要).我想取这些点并创建一组代表轮廓的矢量,这样我就可以在Google地球上绘图.

所以,像:

  #                       #
           #             #       #
#             #    #
      #   #

            #

会给:

  #-----------------------#--
 /                            \ --#
#                  #------------/
 \-----#         /
         \     /
            #

我想出的一个可能的解决方案是计算每个点之间的向量,并丢弃与另一个向量重叠的每个向量.我还没有实现这个(不太确定如何),但我想知道是否还有其他方法.

该算法只需要运行几次,所以如果每次运行需要一个小时,那么RAM就不是问题.

• 有关
• 有关

我想动态调用一个MethodInfo对象,并且从它内部抛出的任何异常向外传递,就像它被正常调用一样.

我看来有两种选择.它们概述如下.

选项1保持抛出的异常的类型MyStaticFunction,但是StackTrace因为它而被破坏throw.

选项2维护StackTrace异常,但异常的类型始终如此TargetInvocationException.我可以提取InnerException它的类型,但这意味着我不能写这个例子:

try { DoDynamicCall(); }
catch (MySpecialException e) { /* special handling */ }

选项1:

void DoDynamicCall()
{
    MethodInfo method = /*referencing MyClass method void MyStaticFunction(int x)*/;
    try
    {
        method.Invoke(null, new object[] { 5 });
    }
    catch (TargetInvocationException e)
    {
        throw e.InnerException;
    }
}

选项2:

void DoDynamicCall()
{
    MethodInfo method = /*referencing MyClass method void MyStaticFunction(int x)*/;
    method.Invoke(null, new …

以下面的界面为例:

interface IOracle
{
    Task<string> GetAnswerAsync(string question);
}

此接口的某些实现可能使用async/ await.其他人可能不需要.例如,考虑这个简单的玩具实现.

class SimpleOracle
{
    public Dictionary<string, string> Lookup { get; set; }

    // Warning CS1998: This async method lacks 'await' operators
    // and will run synchonously.
    public async Task<string> GetAnswerAsync(string question)
    {
        string answer = Lookup[question];
        return answer;
    }
}

编译器警告CS1998当然是有道理的.通常的建议是删除async关键字并使用Task.FromResult,但它错过了一个微妙的问题.如果代码抛出异常怎么办？然后该代码转换改变了方法的行为:async版本将包装任何异常Task; 非async版本不会,没有明确的try- catch.

让async关键字完全按照我的意愿工作,但它会产生编译器警告,我不认为压制这些是明智的.

我应该如何重构我的方法实现以不产生编译器警告,同时用Task任何其他async方法包装所有异常？

请考虑以下设置.

class I
{
public:
    virtual void F() = 0;
};

class A : public I
{
public:
    void F() { /* some implementation */ }
};

class B : public I
{
public:
    void F() { /* some implementation */ }
};

这允许我编写如下函数.

std::shared_ptr<I> make_I(bool x)
{
    if (x) return std::make_shared<A>();
    else return std::make_shared<B>();
}

在这种情况下,我为继承和多态性支付一些费用,即有一个vtable,并且F当使用时调用不能内联如下(如果我错了,请纠正我).

auto i = make_I(false);
i->F(); //can't be inlined

我想知道的是,当使用A或B作为堆栈上分配的对象时,我必须支付相同的费用,如下面的代码所示.

A a;
a.F();

做A和B在栈上分配有虚函数表？电话会 …

我必须DateTime用yyyyMMddhhmmss格式解析字符串中的对象.

如果我运行此代码,它可以正常工作:

DateTime y = new DateTime(2013, 07, 22, 15, 35, 23);
string x = y.ToString("yyyyMMddhhmmss", CultureInfo.InvariantCulture);

但是,如果我运行此代码 - 看似相反的操作 - 我得到一个例外:

string x = "20130722153523";
DateTime y = DateTime.ParseExact(x, "yyyyMMddhhmmss", CultureInfo.InvariantCulture);

例外是:

System.FormatException: String was not recognized as a valid DateTime.

我很难过这里有什么不对劲.我究竟做错了什么？

注意:不要担心时区.我可以稍后处理获得正确的时区.

假设我有以下内容.

struct A
{
    int x;
    std::function<int()> f1() { return [=](){ return x; }; }
    std::function<int()> f2() { return [=](){ return this->x; }; }
    std::function<int()> f3() { return [this](){ return x; }; }
    std::function<int()> f4() { return [this](){ return this->x; }; }
    std::function<int()> f5()
    {
        int temp = x;
        return [=](){ return temp; };
    }
}

现在我有以下代码.

auto a = std::make_shared<A>();
a->x = 5;
std::function<int()> f = a.f#();
a.reset();
int x = f();

在哪里f#指的是任何一个f1, f2, f3, f4, …

假设我有一个M元素数组,所有数字,负数或正数或零.

任何人都可以建议一种算法N从数组中选择元素,这样这些N元素的总和是最小的正数吗？

以此数组为例:

-1000,-700,-400,-200,-100,-50,10,100,300,600,800,1200

现在我必须选择任何5个元素,使得它们的总和是可能的最小正数.