小编Che*_*hen的帖子

也许有点棘手,但我想知道为什么.在System.Linq.Enumerable.cs的System.Core.dll,我们有:

public static int Count<TSource>(this IEnumerable<TSource> source);

在我的代码中,我正在做一些邪恶的事:

namespace Test
{
   public static class Extensions
   {
     public static int Count<TSource>(this IEnumerable<TSource> source)
     {
        return -1; //evil code
     }
   }

   //commented temporarily
   //public static class CommentedExtensions
   //{
   //  public static int Count<TSource>(this IEnumerable<TSource> source)
   //  {
   //     return -2; //another evil code
   //  }
   //}

   public static void Main(string[] args)
   {
     Console.WriteLine(Enumerable.Range(0,10).Count());   // -1, evil code works
     Console.Read();
   }
}

如果我取消注释CommentedExtensions,我将收到一个编译错误,说"这个调用是不明确的blabla",如预期的那样.但为什么我第一次没有得到这个错误？这也很暧昧!

编辑经过另一次测试后,我发现如果扩展方法位于不同的命名空间中,我将不会遇到编译错误,即使它们完全相同.为什么允许这样做？它在c#中引入了模糊的方法调用.

EDIT2我知道其实两个 …

当前在我的模型类中，我有一些JSON.NET属性，例如

public class MyModel
{
     [JsonProperty("_anothername")]
     [JsonConverter(typeof(MyCustomConverter))]
     public string Name { get; set; }     
}

是否有其他解决方案不会“污染”我的模型类？合同解析器可能有效，但是它太重了。我想要这样的东西：

var contract = new JsonContract<MyModel>();
contract.Property(m => m.Name)
        .HasAlias("_anothername")
        .HasConverter<MyCustomConverter>();
JsonConvert.SerializeObject(myModelInstance, contract);

理想情况下，模型类对JSON.NET一无所知，并且该项目不应具有JSON.NET参考。

编辑：也许其他一些JSON库可以工作，但是我不想涉及另一个库，因为JSON.NET在该项目中被广泛使用。

更新：似乎合同解析器是执行此操作的标准方法，我发现此库接近我的期望。稍后，我将尝试编写自己的实现。

有一个结构列表或者一个数组列表,每个都有3个元素,比如

12 8 7
5  1 0
7  3 2
10 6 5
6  2 1
8  4 3
6  1 5
7  2 6
8  3 7
9  4 8
11 7 6
13 9 8
11 6 10
12 7 11
13 8 12
14 9 13

我想摆脱列表中有2个共同子项的项目,在我想删除的示例中

5  1 0
6  2 1
6  1 5
7  3 2
7  2 6
8  4 3
8  3 7   has 2 same items as row 7,3,2
9  4 …

或者这被认为是不好的做法还是什么？

我有一个通知触发 4-5 个处理程序，这些处理程序又调用数据库来检索数据。每个这些调用也可以单独调用，因此它们本身就是请求/处理程序。

谢谢。

我希望textbox1.text的输入显示在占位符{0}中,这样如果textbox1.text ="Randy"我想要一个消息框弹出并说出名字,Randy

MessageBox.Show("First Name,{0}", textBox1.Text);

目前发生的事情是弹出一个消息框并说出名字{0}

我有以下代码用于模拟实时数据源,它同时发送一条消息,"Portfolio.Symbols"内的集合中每个"Symbol"类型的对象都应该响应(通过另一种方法对其进行一些处理).

为了使它同时成立,我尝试以下列方式注册匿名事件处理程序:

static public void RegisterEvents()
{
   foreach (Symbol symbol in Portfolio.Symbols)
   {
      GenerateQuoteRequest += () => { SomeMethod(symbol); };
   }
}

static public void Run()
{
   OnGenerateQuoteRequest();
   Thread.Sleep(100);
}

public delegate void OnGenerateQuoteRequestEventHandler();     
public static event OnGenerateQuoteRequestEventHandler GenerateQuoteRequest 
                                            = delegate {};
...

然后我尝试提升事件,希望我会得到一些"SomeMethod"实例启动.不幸的是,只调用了最后添加的"符号".

我在这里错过了什么？

有没有办法在我的C#文件中修复"使用"？我在NetBeans或Eclise for java中寻找某种"修复(组织)导入".我正在寻找解决问题的最简单方法:当我错过一些"使用"指令时,"无法找到类型或命名空间".实际上,我不记得所有C#类层次结构.

我认同.但是看看asp.net中的内置类:

public sealed class HttpPostedFile
{
    public Stream InputStream { get; }   // Stream implements IDisposable
    // other properties and methods
}

假设我有一个HttpPostedFile被调用的实例file.由于没有Dispose显式调用的方法,file.InputStream.Dispose()因此在被破坏之前不会被调用,我认为这与原来的内涵相违背IDisposable.我认为正确的实现应包含标准IDisposable实现.因此,如果其中一个成员实现IDisposable,该类也需要实现它.你有什么看法？这看起来有点复杂.

从下面的测试我们可以看到框架的当前版本保证输出顺序与输入任务相同.

async Task<string> GetString1()
{
    await Task.Delay(2000);
    return "1";
}

async Task<string> GetString2()
{
    await Task.Delay(1000);
    return "2";
}

var results = await Task.WhenAll(GetString1(), GetString2());
//now we have results[0] == "1" results[1] == "2"

但是从文档中我找不到任何有关此行为的信息,这意味着它不是文档保证.从这个问题的答案的意见

Q1:我需要在输出中加上"订单标志"吗？将示例代码更改为以下内容:

class OrderTaskResult<T>
{
    public OrderTaskResult(int order, T value)
    {
        this.Order = order;
        this.Value = value;
    }
    public int Order { get; private set; }
    public T Value { get; private set; }
}

async Task<OrderTaskResult<string>> GetString1()
{
    await …

假设我有以下代码：

//handler.hpp
template<typename T>
class handler
{
private:
    static void process_core(const T& request) { }
public:
    static void process(const T& request)
    {
        try
        {
            process_core(request);
        }
        catch(const std::exception& e)
        {
            std::cout << "exception " << e.what() << std::endl;
        }
    }
};

//string_handler.cpp
template<> void handler<std::string>::process_core(const std::string& s)
{
    std::cout << "string_handler" << std::endl;
    throw std::invalid_argument("bang");
}

//test.cpp
int main()
{
    handler<std::string>::process("123");
}

我认为std::invalid_arguemnt应该捕获并处理异常，但事实并非如此。程序崩溃：

string_handler
terminate called after throwing an instance of 'std::invalid_argument'
  what():  bang
Aborted (core dumped)

有趣的事情是： …