小编Che*_*hen的帖子

我想我已经知道了一堂课的答案,只想确认我的理解是正确的.假设我有一个ClassA名为的实例a.何时a.MethodA()被调用:

(1)CLR找到的类型ClassA由所述类型的指针的a在堆(类型已经装载到堆)

(2)MethodA在类型中找到,如果没有找到,则转到它的基类型,直到object上课.

也许我的理解不太准确,但我认为这是基本正确的(纠正我,如果它是错的!).这是一个简单结构的问题.

struct MyStruct
{
   public void MethodA() { }
}

我有var x = new MyStruct();,它的值在堆栈上,并且MyStruct已经加载到堆中的类型.执行时x.MethodA(),当然没有拳击.CLR如何找到MethodA并获取IL并执行/ JIT呢？我想答案可能是:(再次,如果我错了,请纠正我)

(1)我们有声明类型的x堆栈上.CLR通过堆栈上的信息找到它的类型,并MethodA在其类型中查找.- 让我们来称呼它assumptionA.

如果你告诉我我assumptionA是对的,我会很高兴的.但即使它是错的,它也说明了一个事实:CLR有一种方法可以在没有装箱的情况下找到结构类型.

现在怎么样x.ToString()还是x.GetType()？我们知道该值将被加框,然后它将像一个类一样执行.但为什么我们需要拳击呢？既然我们可以得到它的类型(假设A告诉我们),为什么不去它的基类型并找到方法(就像一个类)？为什么这里需要昂贵的箱子操作？

可能重复:
为什么我需要一个IoC容器而不是直接的DI代码？

我读了一些关于这个主题的文章,但我没有找到任何明显的优点.例如这段代码:

//some action in a controller
//simplest solution:
var repository = new EmployeeRepository();
var model = repository.ListAllEmployees();

你可能会说:在这个解决方案中,控制器/动作在很大程度上取决于EmployeeRepository.依赖性解析是:

var repository = DependencyResolver.Current.GetService<IEmployeeRepository>();
var model = repository.ListAllEmployees();

没有任何依赖性解决方案/ ioc我没有发现它比下面的更好:

var model = Managers.EmployeeManager.ListAllEmployees();

希望有人能就这个主题给我一些想法/链接/帖子.

我刚看到一个类似的代码

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < n; i++)
        {
            result.Append("?");
        }
        return result.ToString();

我知道与StringBuilder连接被认为更快(并且不会在每个追加上创建字符串的新实例).但是我们有什么理由不喜欢写作

return new string('?', n) 

代替？

假设我有一个名为/ getdata的接口的asp.net mvc 3应用程序,不同的用户通过我的PC客户端软件连接到服务器并使用此接口获取私有数据.不同的用户通过他们自己的良好加密的令牌来识别.

现在的问题是ClientA告诉我们他得到了另一个用户的数据.从ClientA的日志中我们发现他得到了ClientB(但他们彼此不认识,他们不能共享帐户).我查看了我的Web应用程序的代码,但没有找到任何机会混合他们的数据.

所以我想知道这会发生:

(1)ClientB 通过Web代理在http标头中使用他的令牌向http://mysite.com/getdata发起http请求.

(2)Web代理访问我的Web服务器,获取ClientB的数据.

(3)我的Web服务器批准请求并返回ClientB的数据,因为一切正确.

(4)ClientB获取他的数据并正确显示

(5)在ClientB获取数据后几乎同一时间,ClientA启动相同的请求,并在标头中添加ClientA的令牌.

(6)Web代理找到ClientA请求的URL与ClientB相同,结果仍在缓存中,然后返回ClientB的数据.然后ClientA获取另一个数据.

在我的Web应用程序界面中,在开始时我已经设置了所有响应no-cache,max-age = 0等等以防止客户端缓存.我的问题是:

1. 图像中的scanario可以发生吗？

2. 如果是,我如何阻止Web代理返回缓存数据？我无法修改PC客户端的程序,并且Web代理服务器不受我的控制.

3. 如果不是,A获得B数据的可能原因是什么？

我正在尝试使用linq的查询语法将此查询转换为基于方法的语法.

这是查询:

  var products = from p in context.Products
                 join t in context.TopSellings
                 on p.Id equals t.Id into g
                 from tps in g.DefaultIfEmpty()
                 orderby tps.Rating descending
                 select new
                 {
                     Name = p.Name,
                     Rating = tps.Rating == null ? 0 : tps.Rating
                 };

上面的查询产生这个SQL查询:

{SELECT 
    [Project1].[Id] AS [Id], 
    [Project1].[Name] AS [Name], 
    [Project1].[C1] AS [C1]
    FROM ( SELECT 
        [Extent1].[Id] AS [Id], 
        [Extent1].[Name] AS [Name], 
        CASE WHEN ([Extent2].[Rating] IS NULL) THEN 0 ELSE [Extent2].[Rating] END AS [C1], 
        [Extent2].[Rating] AS [Rating]
        FROM  [dbo].[Products] AS …

我喜欢在linq或linq的扩展方法中调用一个没有return-type的方法？在这里我的班级我有这种情况

Class A
{
   int i;
   public int K
   {
     get { return i; }
     set { i = value; }
   }
   public void calculate(int z)
   {
     this.k=z;
   }
}

我喜欢这样做

List<A> sam = new List<A>();
//add elements to this list
var c = sam.Select( s => s.calculate(4) );

这个样本,我喜欢这样做,为了我的目的.

我正在尝试为一些遗留代码创建单元测试.我必须测试的一个类叫做FileDownloader,它只有以下一个方法:

public void Transmit(string fileName, HttpResponse response, DownloadFileType fileType, byte[] content)
{
    response.Clear();
    response.ClearHeaders();
    response.ContentType = "application/xls";
    response.AddHeader("content-disposition", "attachment; filename=" + HttpContext.Current.Server.UrlEncode(fileName));
    response.BinaryWrite(content);
    response.End();
    response.Flush();
}

我不允许重构这个代码(这本来是理想的!).

为了测试这个,我决定根据下面的文章创建一个假的HttpContext

点击这个

有了这个,我可以在测试执行期间获得假的HttpContext,但是伪造HttpResponse存在问题.

以下是我的测试结果:

[SetUp]
public void SetUp()
{
    mocks = new MockRepository();            
    FakeHttpContext.CreateFakeHttpContext();
}

[Test]
public void ShouldTransmitHttpResponseInTheSpecifiedFormat()
{
    FileDownloader downloader = new FileDownloader();
    string path = "..\\..\\Fakes\\DummyDownloadReportsTemplate.xls";
    byte[] bytes = ReadByteArrayFromFile(path);
    downloader.Transmit("test.xls", new HttpResponse(new StringWriter()), DownloadFileType.Excel, bytes);
}

我正在将自定义创建的HTTPResponse对象传递给该方法.当它命中"response.BinaryWrite(content)"行时抛出以下异常:

System.Web.HttpException:使用自定义TextWriter时,OutputStream不可用.

我不确定我究竟应该在这里断言...因此在测试中没有断言.这是测试这种方法的正确方法......任何想法.请指教 ？

谢谢

基本上假设你有一些收藏:

public class FurCollection : IEnumerable<FurStrand>
{
   public IEnumerator<FurStrand> GetEnumerator()
   {
      foreach(var strand in this.Strands)
      {
         yield return strand;
      }
   }

   IEnumerator IEnumerable.GetEnumerator()
   {
      return this.GetEnumerator();
   }
}

这可以接受吗？或者这是容易出错还是不好的做法？我几乎总是使用IEnumerator<T>但我仍然希望非通用版本稳定并正确实现.

目前我正在使用sqlite构建一个Windows应用程序.在数据库中有一个表说User,在我的代码中有一个Repository<User>和一个UserManager.我认为这是一个非常常见的设计.在存储库中有一个List方法:

//Repository<User> class
public List<User> List(where, orderby, topN parameters and etc)
{
    //query and return
}

这带来了一个问题,如果我想做一些复杂的事情UserManager.cs:

//UserManager.cs
public List<User> ListUsersWithBankAccounts()
{
    var userRep = new UserRepository();
    var bankRep = new BankAccountRepository();
    var result = //do something complex, say "I want the users live in NY 
                 //and have at least two bank accounts in the system
}

你可以看到,返回List<User>会带来性能问题,因为查询的执行时间早于预期.现在我需要将其更改为IQueryable<T>:

//Repository<User> class
public TableQuery<User> List(where, orderby, topN parameters …

我要调用的方法foo()超时（例如1分钟）。如果执行时间少于1分钟，则返回结果。否则将引发异常。这是代码：

//PRINT "START" IN THE LOG
auto m = std::make_shared<std::mutex>();
auto cv = std::make_shared<std::condition_variable>();
auto ready = std::make_shared<bool>(false);
auto response = std::make_shared<TResponse>();
auto exception = std::make_shared<FooException>();
exception->Code = ErrorCode::None;

std::thread([=]
{
    std::unique_lock<std::mutex> lk(*m);
    cv->wait(lk, [=]{ return *ready; });

    try
    {
        //PRINT "PROCESS" IN THE LOG
        auto r = foo();
        *response = std::move(r);
    }
    catch(const FooException& e)
    {
        *exception = std::move(e);
    }

    lk.unlock();
    cv->notify_one();
}).detach();

std::unique_lock<std::mutex> lk(*m);
*ready = true;
cv->notify_one();
auto status = cv->wait_for(lk, std::chrono::seconds(60));
if (status == …