小编Ale*_*lex的帖子

我有多个大对象,每个对象有大约60个字符串.我必须修剪所有这些字符串,我想这样做而不必去this.mystring = this.mystring.Trim().相反,我正在寻找一种方法来自动让每个对象发现自己的字符串,然后执行操作.

我对反思有点了解,但还不够,但我认为这是可能的吗？

另外,我不确定这是否重要,但是一些字符串属性是只读的(只有一个getter),因此必须跳过这些属性.

救命？

我(现在比以往任何时候都更多)看到开发人员编写了大量的图层,例如:

implementation PresentationLayer ->
    interface IMyDTO ->
        implementation MyDTO ->
            interface IMyService -> 
                implementation MyService -> 
                    interface IMyDomainRepository ->
                        implementation MyDomainRepository ->
                            interface IMyDomainObject -> 
                                implementation MyDomainObject ->
                                    interface IMyIndependentStorageLayer ->
                                        implementation MyMSSQLStorageLayer

通过C#博客看,这似乎是自切片面包以来最好的事情.基本上,一切都松散耦合.不要直接使用域对象.通过服务层运行所有内容.通过存储库访问数据.所有图层都完全独立.

不要误解我的意思,我喜欢这个想法,但是不是时间上的权衡,特别是在一个更大的项目上？维护的投资回报率是否真的足以证明这一点？

我读到的解释有点尴尬,例如"如果需要,我可以附加不同的数据库".真？我不认为这是一个常见的问题,有人突然要求从MSSQL切换到Oracle,现在你坐在那里,希望你有一百万个层,彼此都不知道.

是否存在松散耦合过度的趋势,或者我只是在阅读错误的博客？你觉得这个怎么样,并且你有过这样的情况,你以后真的很高兴你在开始时做了额外的工作吗？

有什么理由(安全？)为什么有人应该重命名 ASP.NET会话Cookie名称或者它只是一个毫无意义的ASP.NET选项？

我喜欢在Javascript中学习Class Property和Prototype之间的区别我的意思是在代码中显示:

function Rectangle(x, y) {
    this.width = x;
    this.height = y;
}

Rectangle.UNIT = new Rectangle(1, 1);

Rectangle.prototype.UNIT = new Rectangle(1, 1);

我知道的东西是原型就像继承对象一样工作,这意味着UNIT将从现在开始显示所有实例,但 Rectangle.UNIT = new Rectangle(1, 1);代码不会做同样的事情吗？

我有以下内容(为了清楚起见缩写) - 一个枚举,一个带有该枚举的基类,以及两个将枚举设置为特定值的派生类.

public enum MyEnum
{ 
    Value1, Value2
}

public class MyBaseClass
{ 
    public MyEnum { get; protected set; }
}

public class DerivedOne: MyBaseClass
{
    public DerivedOne { MyEnum = MyEnum.Value1; } 
}

public class DerivedTwo: MyBaseClass
{
    public DerivedTwo { MyEnum = MyEnum.Value2; }
}

我想要做的是让Entity Framework 5自动区分DerivedOne和DerivedTwo,并使用基于MyEnum值的鉴别器.我应该能够这样做,按照惯例,每个MyEnum == MyEnum.Value1代表DerivedOne,而MyEnum == MyEnum.Value2代表DerivedTwo.

我在我的DbContext中试过这个:

public class MyDbContext : DbContext
{
    DbSet<MyBaseClass> MyBaseClass { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<MyBaseClass>()
                    .Map<DerivedOne>(m => m.Requires(x …

实例方法和扩展方法之间是否存在性能差异？

我想知道是否/如何覆盖ASP.NET MVC中的默认[Authorize]行为.我知道我可以创建一个新的Action Filter,创建自己的属性等等; 我只是感兴趣,如果我可以简单地更改[授权]行为并用我自己的代码替换它的工作？

编辑:男孩和女孩.感谢您的意见,但正如我所写,我不打算引入新的[XYZAuthorize]属性.我知道怎么做.我想保留[授权]符号,但只是改变它的工作原理.

Expression <>究竟在C#中使用了什么？是否有任何情况下您将Expression <>自己实例化为对象？如果是这样,请举个例子!

谢谢!

我正在使用EF6,并希望使以下查询完全异步:

 await MyDataContext.ADbSet.
                     First(a => a.Something == "Something").
                     ASubCollection.
                     Select(x => new { x.SubCollectionId }).
                     ToListAsync();

这不起作用,我相信由于First()返回实际的实体和访问ASubCollection是一个ICollection,而不是一个IQueryable.

我能够使用以下代码解决此问题:

 await MyDataContext.ADbSet.
                     Where(a => a.Something == "Something").
                     SelectMany(a => a.ASubCollection).
                     Select(x => new { x.SubCollectionId }).
                     ToListAsync();

然而,这似乎是"hacky",因为我正在使用一个Where(...)我应该使用的,First()因为我在编译时知道将只有一个元素满足查询.有没有更好的方法呢？

我正在寻找关于异步/等待有意义的"工作负载阈值"(例如释放IO完成端口并避免线程饥饿)与工作单元执行过于简单/便宜之间的一些指导,因此同步执行是一个更好的选择.

换句话说,当与相对快速/资源廉价的工作单元结合使用时,async/await的使用是否会导致性能下降,并且简单地同步执行工作将是首选方法？

示例(所有在一个方法中,都与await异步):

• 保存对DB的一些小更新
• 使用读取非常小的文件上传到流 ReadAsStreamAsync
• 使用将文件流复制到文件流 CopyToAsync
• 刷新写入器流使用 FlushAsync