小编Ben*_*ter的帖子

是否有内置对象以与哈希表类似的方式处理3个链接值？即Key,Value1,Value2？

我有一个基类:

public abstract class StuffBase
{
    public abstract void DoSomething();
}

还有两个派生类

public class Stuff1 : StuffBase
{
    public void DoSomething()
    {
        Console.WriteLine("Stuff 1 did something cool!");
    }
    public Stuff1()
    {
        Console.WriteLine("New stuff 1 reporting for duty!");
    }
}

public class Stuff2 : StuffBase
{
    public void DoSomething()
    {
        Console.WriteLine("Stuff 2 did something cool!");
    }
    public Stuff1()
    {
        Console.WriteLine("New stuff 2 reporting for duty!");
    }
}

好的,现在说我有一个项目列表:

var items = new List<StuffBase>();
items.Add(new Stuff1());
items.Add(new Stuff2());

我希望他们都能调用他们的DoSomething()方法.我可以期望只是迭代列表并调用他们的DoSomething()方法,所以让我们说我有一个方法来做这个叫做AllDoSomething()的方法只是遍历列表并完成工作:

public static void …

作为一个理论练习,帮助我学习与MVC相关的成员模型的细节,我想弄清楚我是否可以从外部资源加载权限,为了我的原型,我有一个平面文件,像这样的列表:

Controller1,Method1,Get,Anonymous
Controller1,Method1,Post,User,Administrator
Controller2,Method1,Get,Administrator
Controller2,Method1,Post,Administrator
Controller2,Method2,Get,User,Editor,Administrator
Controller2,Method2,Post,Editor,Administrator

我可以使用正则表达式解析,以便为我提供一个对每个控制器/动作/动词组合具有权限的角色列表.

我有我的控制器动作:

[CustomAuthorize]
public ActionResult Index()
{
    /* Do stuff */
}

我也有我的自定义授权组件:

public class CustomAuthorize : AuthorizeAttribute
{
    protected override bool AuthorizeCore(HttpContextBase httpContext)
    {
        /* How do I access which Controller/Action/Verb fired this? */
    }
}

为了能够在运行中确定哪些角色可以访问此控制器/动作/动词,我需要能够确定哪个控制器/动作/动词称为CustomAuthorize属性.

我知道我可以像这样向我的类添加属性:

public class CustomAuthorize : AuthorizeAttribute
{
    public string Controller { get; set; }
    public string Action { get; set; }
    public string Verb { get; set; }
}

然后调用我的属性:

[CustomAuthorize(Controller="Home",Action="Index",Verb="Get")]
public ActionResult Index()
{ …

最近我的一位朋友问我是刚刚开始玩线程的,主要是为了锁定或只是锁定你引用的对象,使用辅助对象之间的区别是什么.我不得不承认我不知道,谁能告诉我？我将尝试使用几个代码片段进行演示:

第一种方法:

List<string> data = new List<string>();
object datalock = new object();

void main()
{
    lock(datalock)
    {
        if (data.contains("SomeSearchString"))
        {
            //Do something with the data and then remove it
        }
    }
}

第二种方法:

List<string> data = new List<string>();

void main()
{
    lock(data)
    {
        if (data.contains("SomeSearchString"))
        {
            //Do something with the data and then remove it
        }
    }
}

是否存在重大差异,还是归结为个人编码风格？如果存在显着差异,有人可以解释它是什么吗？

我确实遇到了另一个问题[ 锁定(锁定器)和锁定(variable_which_I_am_using)之间的区别 ],其中答案暗示这两者都是等效的,但如果是这样的话,那将是最好用的,为什么？

我已经看到一些散布在网络上的例子,我倾向于使用第一种方法作为个人选择的问题,但我想知道使用第二种方法的优点是什么.

我已经找到了很多这方面的实际例子,并且在覆盖或隐藏方法时理解实际输出,但是我正在寻找一些有关为什么会出现这种情况的信息以及为什么C#根据多态性规则允许它时,这不应该被允许 - 至少,就我对多态性的理解而言(这似乎与维基百科/ Webopedia上的标准定义一致).

Class Base
{
    public virtual void PrintName()
    {
        Console.WriteLine("BaseClass");
    }
}

Class FirstDerived : Base
{
    public override void PrintName()
    {
        Console.WriteLine("FirstDerived");
    }
}

Class SecondDerived : Base
{
    public new void PrintName()
    {
        Console.WriteLine("SecondDerived");
    }
}

使用以下代码:

FirstDerived b = new FirstDerived();
BaseClass a = b;
b.PrintName();
a.PrintName();

我明白了:

FirstDerived FirstDerived

好的,我明白了,这很有道理.

SecondDerived c = new SecondDerived();
BaseClass a = c;
c.PrintName();
a.PrintName();

我明白了:

SecondDerived 
BaseClass

好吧,这也是有道理的,实例a看不到c.PrintName()所以它使用自己的方法来打印自己的名称,但是我可以使用以下命令将我的实例转换为其真实类型:

((SecondDerived)a).PrintName();

要么

(a as SecondDerived).PrintName();

获得我期望的输出:

SecondDerived

那么在幕后发生了什么,这在多态性方面意味着什么呢？我被告知这个设施"打破了多态性" …

我从数据库中提取序列化数据以及对象类型(其中一个字段包含对象类型,一个字段包含序列化数据的XML字符串).

我有一个具有序列化和反序列化方法的通用序列化程序:

public static class Serializer<T>
{
    public static string Serialize(T objectData) { }
    public static T Deserialize(string xmlData) { }
}

鉴于在数据库字段中指定了对象类型,有没有办法让我动态设置T是什么？ - 这是我的想法(尽管这不起作用):

Type t = Type.GetType(objectTypeName);
t objData = Serializer<t>.Deserialize(objectXmlString);

我希望从switch语句中重构一些代码,其中T是一个设定值,但我无法弄清楚它是否可以完成,或者如果是这样,我将如何去做.

提前致谢.

是否可以根据where子句的不同来计算多个聚合？例如:

假设我有两个表,一个用于Invoice,另一个用于InvoiceLineItems.发票表具有发票总额的总字段,InvoiceLineItems表中的每个发票行项记录都包含一个字段,表示该行项目是否可折扣.我想要三个总和,一个是Discountable = 0,一个是Discountable = 1,另一个是Discountable无关紧要.这样我的输出将是:

InvoiceNumber  Total  DiscountableTotal  NonDiscountableTotal
-------------  -----  -----------------  --------------------
1              53.27  27.27              16.00
2              38.94   4.76              34.18
3...

到目前为止我找到的唯一方法是使用类似的东西:

Select i.InvoiceNumber,
       i.Total,
       t0.Total As DiscountableTotal,
       t1.Total As NonDiscountableTotal
From   Invoices i
    Left Join (
        Select   InvoiceNumber,
                 Sum(Amount),
        From     InvoiceLineItems
        Where    Discountable = 0
        Group By InvoiceNumber
    ) As t0 On i.InvoiceNumber = t0.InvoiceNumber
    Left Join (
        Select   InvoiceNumber,
                 Sum(Amount)
        From     InvoiceLineItems
        Where    Discountable = 1
        Group By InvoiceNumber
    ) As t1 On i.InvoiceNumber = t1.InvoiceNumber …

LINQ的并行扩展会自动检测核心数量并全部利用它们吗？相反,如果代码在单个核心机器上运行,它仍然可以工作,还是我必须检测核心数量并告诉PLINQ要运行多少个？

可悲的是,我无法访问任何单个核心机器来测试我的代码所以我甚至无法为自己测试这个并且我无法在其他地方找到任何有用的信息...

此外,虽然最初看起来很明显何时使用并行性,但是它是否有任何关于它应该在哪里的经验法则,并且重要的是不应该使用它？

附注:我不一定在特定环境中编程.我倾向于根据手头的任务在Web,客户端/服务器应用程序,Windows应用程序,Windows服务和控制台实用程序之间平等地分配我的时间(取决于项目).