C#的隐藏功能？

通过下降switch- caseS可通过不具有代码在一个来实现case(见case 0),或者使用特殊的goto case(见case 1)或goto default(见case 2)形式:

switch (/*...*/) {
    case 0: // shares the exact same code as case 1
    case 1:
        // do something
        goto case 2;
    case 2:
        // do something else
        goto default;
    default:
        // do something entirely different
        break;
}

我错过了很长一段时间的东西:你可以比较字符串

"string".equals("String", StringComparison.InvariantCultureIgnoreCase)

而不是做:

"string".ToLower() == "String".ToLower();

如果方法参数实现了两个接口,则可以使用泛型来检查(编译时):

interface IPropA 
{
    string PropA { get; set; } 
}

interface IPropB 
{
    string PropB { get; set; }
}

class TestClass 
{
    void DoSomething(T t) where T : IPropA, IPropB 
    {
        MessageBox.Show(t.PropA);
        MessageBox.Show(t.PropB);
    }
}

与从基类和接口继承的参数相同.

我能想到的一对夫妇:

[field: NonSerialized()]
public EventHandler event SomeEvent;

这可以防止事件被序列化.'field:'表示该属性应该应用于事件的支持字段.

另一个鲜为人知的功能是覆盖add/remove事件处理程序:

public event EventHandler SomeEvent
{
    add
    {
        // ...
    }

    remove
    {
        // ...
    }
}

我喜欢这样的事实:我可以在普通的旧版.NET 2.0上使用LINQ来对象(即不需要在任何地方安装.NET 3.5).您所需要的只是所有查询运算符Extension方法的实现 - 请参阅LINQBridge

我还无法发表评论,但请注意,默认情况下,Visual Studio 2008会自动切换属性,因此在这种情况下不再需要DebuggerStepThrough属性.

另外,我没有注意到有人展示如何声明一个无参数的lambda(对于实现Action <>很有用)

() => DoSomething(x);

你还应该阅读关闭 - 我不够聪明,无法正确解释它们.但基本上它意味着编译器会做一些聪明的事情,以便即使在创建lambda之后它超出范围,代码行中的x仍然可以工作.

我最近也发现你可以假装忽略一个lambda参数:

(e, _) => DoSomething(e)

它并不是真的忽略它,只是_是一个有效的标识符.所以你不能忽略这两个参数,但我认为这是一种巧妙的方式来表明我们不关心那个参数(通常是EventArgs .Empty).

在声明的类和一个或多个任意类之间存在用于执行implicit和explicit用户定义的类型转换的运算符.的implicit操作者有效地允许重载assignement操作者,这是在语言可能的,诸如C++但不C#的模拟.

它似乎不是经常出现的功能,但实际上它在LINQ to XML(System.Xml.Linq)库中使用,您可以在其中隐式地将字符串转换为XName对象.例:

XName tagName = "x:Name";

我在本文中发现了有关如何在C#中模拟多重继承的这一特性.

委托语法已经在C#的连续版本中发展,但我仍然发现它们很难记住.幸运的是Action<>,Func<>代表们很容易记住.

例如:

Action 是一个委托方法,它接受一个int参数并返回void.

Func 是一个委托方法,不带参数并返回一个int.

Func 是一个委托方法,它接受一个int参数并返回一个bool.

这些功能是在.NET框架的3.5版本中引入的.

可以调用扩展方法null; 这不会导致NullReferenceException抛出.

示例应用程序:您可以为ToString()被调用定义一个替代方法ToStringOrEmpty(),它将在调用时返回空字符串null.

要调用基类构造函数,只需将base()与构造函数内联.
要调用基类方法,只需将base.MethodName()放在派生类方法中即可

class ClassA 
{
  public ClassA(int a)
  {
    //Do something
  }

  public void Method1()
  {
     //Do Something
  }
}

class ClassB : ClassA
{
  public ClassB(int a) : base(a) // calling the base class constructor
  {
    //Do something
  }

  public void Method2()
  {
    base.Method1();               // calling the base class method
  }
}

当然,你只需说出就可以调用基类的方法 base.MethodName()

TrueForAll方法List:

List s = new List { 6, 1, 2 };

bool a = s.TrueForAll(p => p > 0);

很少有人知道的一件事是一些C#引入的预处理器指令.您可以使用#error This is an error.生成编译器错误和#warning This is a warning.

当我使用自上而下的方法开发作为"待办事项"列表时,我通常使用这些.我会#error Implement this function,或者#warning Eventually implement this corner case作为提醒.

不确定这个是否已被提及,但ThreadStatic属性是一个非常有用的属性.这使静态字段仅为当前线程静态.

[ThreadStatic]
private static int _ThreadStaticInteger;

你不应该包含一个初始值设定项,因为它只对整个应用程序执行一次,你最好使字段可以为空,并在使用之前检查值是否为null.

ASP.NET应用程序线程的另一个用途是重用,因此如果修改该值,它最终可能会被用于另一个页面请求.

我仍然发现这有用几次.例如,在创建自定义事务类时:

using (DbTransaction tran = new DbTransaction())
{
    DoQuery("...");
    DoQuery("...");    
}

DbTransaction构造函数将ThreadStatic字段设置为self,并在dispose方法中将其重置为null.DoQuery检查静态字段,如果!= null使用当前事务,否则默认为其他事务.我们避免必须将事务传递给每个方法,而且它可以很容易地包装其他方法,这些方法原本不是用于事务中的事务...

只需一次使用:)

该Or赋值运算符是相当不错的.你可以这样写:

x |= y

而不是这个:

x = x | y

如果你有一个变量或属性(这通常是实际x启动了作为例子)false,但你想改变它的一些其他的布尔变量/属性的值,只有当其他值true.

嵌套类可以访问外部类的私有成员.

public class Outer
{
    private int Value { get; set; }

    public class Inner
    {
        protected void ModifyOuterMember(Outer outer, int value)
        {
            outer.Value = value;
        }
    }
}

现在,与上述功能一起,您也可以从嵌套类继承,就像它们是顶级类一样,如下所示.

public class Cheater : Outer.Inner
{
    protected void MakeValue5(Outer outer)
    {
        ModifyOuterMember(outer, 5);
    }
}

这些功能允许一些有趣的可能性,只要通过隐藏的类提供对特定成员的访问.

您可以使用以下方法更改舍入方案:

var value = -0.5;
var value2 = 0.5;
var value3 = 1.4;

Console.WriteLine( Math.Round(value, MidpointRounding.AwayFromZero) ); //out: -1
Console.WriteLine(Math.Round(value2, MidpointRounding.AwayFromZero)); //out: 1
Console.WriteLine(Math.Round(value3, MidpointRounding.ToEven)); //out: 1

如果您希望在调试和释放模式之间使用不同的行为,那么预处理器指令可能很有用.

http://msdn.microsoft.com/en-us/library/ed8yd1ha.aspx

System.Diagnostics.Debug.Assert (false);

将触发弹出窗口并允许您在执行期间将调试器附加到正在运行的.NET进程.由于某些原因您无法直接调试ASP.NET应用程序时非常有用.

字符串实习.这是我尚未见过的讨论.它有点模糊,但在某些条件下它可能是有用的.

CLR保留一个对文字字符串的引用表(以及以编程方式实现的字符串).如果在代码中的多个位置使用相同的字符串,它将在表中存储一次.这可以减轻分配字符串所需的内存量.

您可以使用String.IsInterned(string)测试字符串是否被中断,并且您可以使用String.Intern(string)实习字符串.

注意: CLR可以在应用程序甚至AppDomain结束后保留​​对实习字符串的引用.有关详细信息,请参阅MSDN文档.

IEnumerable的SelectMany,它将列表列表展平为单个列表.假设我有一个清单Orders,每个Order清单都有一个清单LineItems.

我想知道LineItems售出的总数......

int totalItems = Orders.Select(o => o.LineItems).SelectMany(i => i).Sum();

使用枚举.

将字符串转换为枚举:

enum MyEnum
{
    FirstValue,
    SecondValue,
    ThirdValue
}

string enumValueString = "FirstValue";
MyEnum val = (MyEnum)Enum.Parse(typeof(MyEnum), enumValueString, true)

我使用它从数据库中的设置表加载我的ASP.NET应用程序中的CacheItemPriority的值,以便我可以动态地控制缓存(以及其他设置),而无需关闭应用程序.

比较enum类型的变量时,不必转换为int:

MyEnum val = MyEnum.SecondValue;
if (val < MyEnum.ThirdValue)
{
    // Do something
}

我非常喜欢函数的隐式泛型参数.例如,如果您有:

public void DoStuff(T value);

而不是像这样调用它:

DoStuff(5);

您可以:

DoStuff(5);

它将从参数的类型中找出泛型类型.

如果您通过反射调用方法,则此方法无效.

我记得在Mono上有一些奇怪的问题.

要使用LINQ 测试IEnumerable 是否为空,请使用:

IEnumerable .Any();

起初,我正在使用(IEnumerable .Count()!= 0)...

这会不必要地导致枚举IEnumerable中的所有项目.

作为对此的改进,我继续使用(IEnumerable .FirstOrDefault()== null)...

哪个更好...

但IEnumerable .Any()是最简洁的,表现最好.

我很确定每个人都熟悉运算符重载,但也许有些不是.

class myClass
{
    private string myClassValue = "";

    public myClass(string myString)
    {
        myClassValue = myString;
    }

    public override string ToString()
    {
        return myClassValue;
    }

    public static myClass operator <<(myClass mc, int shiftLen)
    {
        string newString = "";
        for (int i = shiftLen; i < mc.myClassValue.Length; i++)
            newString += mc.myClassValue[i].ToString();
        mc.myClassValue = newString.ToString();
        return mc;
    }

    public static myClass operator >>(myClass mc, int shiftLen)
    {
        char[] newString = new char[shiftLen + mc.myClassValue.Length];

        for (int i = shiftLen; i < mc.myClassValue.Length; i++)
            newString[i] += mc.myClassValue[i - shiftLen];

        mc.myClassValue = new string(newString);
        return mc;
    }

    public static myClass operator +(myClass mc, string args)
    {
        if (args.Trim().Length > 1)
            mc.myClassValue += args;
        return mc;
    }

    public static myClass operator -(myClass mc, string args)
    {
        if (args.Trim().Length > 1)
        {
            Regex rgx = new Regex(args);
            mc.myClassValue = rgx.Replace(mc.myClassValue, "");
        }
        return mc;
    }
}

我认为能够使用<<和>>左右移动字符串或使用 - =删除一组遵循正则表达式模式的字符串是非常酷的

myClass tmpClass = new myClass("  HelloWorld123");
tmpClass -= @"World";
tmpClass <<= 2;
Console.WriteLine(tmpClass);

不是C#特定的东西,但我是一个三元手术迷.

代替

if (boolean Condition)
{
    //Do Function
}
else
{
    //Do something else
}

你可以使用简洁

booleanCondtion ? true operation : false operation;

例如

代替

int value = param;
if (doubleValue)
{
    value *= 2;
}
else
{
    value *= 3;
}

你可以输入

int value = param * (tripleValue ? 3 : 2);

它确实有助于编写简洁的代码,但嵌套该死的东西可能是令人讨厌的,它们可以用于邪恶,但我喜欢这些小吸盘

你可以打开字符串!

switch(name)
{
  case "Dave":
    return true;
  case "Bob":
    return false;
  default:
    throw new ApplicationException();
}

非常便利!并且比一堆if-else语句更清晰

而不是做这样的俗气:

Console.WriteLine("{0} item(s) found.", count);

我使用以下内联技巧:

Console.WriteLine("{0} item{1} found.", count, count==1 ? "" : "s");

当有一个项目时,这将显示"项目",或者当有更多(或更少)项目时,这将显示"项目".没有多少努力获得一点专业性.

在C#3.5中初始化Dictionary的表达式:

new Dictionary() {{"Testing", 123}, {"Test", 125}};

C#允许您将属性setter方法添加到实现只读接口属性的具体类型,即使接口声明本身没有属性设置器.例如:

public interface IReadOnlyFoo
{
   object SomeReadOnlyProperty { get; }
}

具体类看起来像这样:

internal class Foo : IReadOnlyFoo
{
   public object SomeReadOnlyProperty { get; internal set; }
}

有趣的是,如果将它转换为IReadOnlyFoo接口,Foo类是不可变的:

// Create a Foo instance
Foo foo = new Foo();

// This statement is legal
foo.SomeReadOnlyProperty = 12345;

// Make Foo read only
IReadOnlyFoo readOnlyFoo = foo;

// This statement won't compile
readOnlyFoo.SomeReadOnlyProperty = 54321;

字典初始化器对于需要对某些数据进行硬编码的快速黑客攻击和单元测试总是很有用.

var dict = new Dictionary { { 10, "Hello" }, { 20, "World" } };

使用LINQ,可以根据参数创建新功能.如果你有一个很常见的微小函数,这是非常好的,但参数需要一些时间来计算.

    public Func RandomGenerator
    {
        get
        {
            var r = new Random();
            return () => { return r.Next(); };
        }
    }

    void SomeFunction()
    {
        var result1 = RandomGenerator();

        var x = RandomGenerator;
        var result2 = x();
    }

除了duncansmart的回复之外,还可以在Framework 2.0上使用扩展方法.只需ExtensionAttribute在System.Runtime.CompilerServices命名空间下添加一个类,就可以使用扩展方法(当然只能使用C#3.0).

namespace System.Runtime.CompilerServices
{
    public class ExtensionAttribute : Attribute
    { 
    }
}

您键入"prop",然后按[TAB]两次,它会为您的属性生成有用的代码,并可以加快您的输入速度.

我知道这可以在VS 2005中使用(我使用它),但我不知道以前的版本.

Object.ReferenceEquals方法

确定指定的Object实例是否是同一实例.

参数:

objA:System.Object - 要比较的第一个Object.

objB:System.Object - 要比较的第二个Object.

例:

 object o = null;
 object p = null;
 object q = new Object();

 Console.WriteLine(Object.ReferenceEquals(o, p));
 p = q;
 Console.WriteLine(Object.ReferenceEquals(p, q));
 Console.WriteLine(Object.ReferenceEquals(o, p));

与"=="和".Equals"的区别:

基本上,对象A的Equals()测试与对象B具有相同的内容.

System.Object.ReferenceEquals()方法始终比较引用.尽管类可以为等于运算符(下面)提供自己的行为,但是如果通过对System.Object的引用调用运算符,则不会调用该重定义的运算符.

对于字符串,没有什么区别,因为已经重写了==和Equals来比较字符串的内容.

另请参阅另一个问题的答案("如何在没有无限递归的情况下检查'=='运算符重载中的空值？").

显式接口成员实现,其中实现接口成员,但隐藏除非将实例强制转换为接口类型.

这不是C#特定类型,但我刚刚找到了ISurrogateSelector和ISerializationSurrogate接口 -

http://msdn.microsoft.com/en-us/library/system.runtime.serialization.isurrogateselector.aspx

http://msdn.microsoft.com/en-us/library/system.runtime.serialization.isurrogateselector.aspx

将这些与BinaryFormatter结合使用可以通过实现代理类来序列化非可序列化对象.代理模式在计算机科学中是很好理解的,特别是在处理序列化问题时.我认为这个实现只是作为BinaryFormatter的构造函数的参数隐藏起来,这太糟糕了.

仍然 - 非常隐藏.:)

C#4.0中的动态关键字

如果希望仅在运行时解析方法调用,则可以使用dynamic关键字.

dynamic invoker=new DynamicInvoker();
dynamic result1=invoker.MyMethod1();
dynamic result2=invoker.MyMethod2();

在这里,我正在实现一个动态调用程序.

public class DynamicInvoker : IDynamicObject
    {
        public MetaObject GetMetaObject
              (System.Linq.Expressions.Expression parameter)
        {
            return new DynamicReaderDispatch (parameter);
        }
    }

    public class DynamicDispatcher : MetaObject
    {
        public DynamicDispatcher (Expression parameter) 
                   : base(parameter, Restrictions.Empty){ }

        public override MetaObject Call(CallAction action, MetaObject[] args)
        {
            //You'll get MyMethod1 and MyMethod2 here (and what ever you call)
            Console.WriteLine("Logic to invoke Method '{0}'", action.Name);
            return this; //Return a meta object
        }
    }

您可以在非泛型类中使用泛型方法.

使用lambda时模拟功能性"通配符"参数(如Haskell中的"_")的酷技巧:

(_, b, __) => b.DoStuff();  // only interested in b here

这是我最近发现的一个有用的:

Microsoft.VisualBasic.Logging.FileLogTraceListener

MSDN链接

这是一个TraceListener实现,它具有许多功能,例如自动日志文件翻转,我以前会使用自定义日志记录框架.好处是它是.NET的核心部分,并与Trace框架集成,因此易于立即使用和使用.

这是"隐藏"的,因为它在Microsoft.VisualBasic程序集中......但您也可以在C#中使用它.

在通用代码中使用default关键字来返回类型的默认值.

public class GenericList
{
    private class Node
    {
        //...

        public Node Next;
        public T Data;
    }

    private Node head;

    //...

    public T GetNext()
    {
        T temp = default(T);

        Node current = head;
        if (current != null)
        {
            temp = current.Data;
            current = current.Next;
        }
        return temp;
    }
}

另一个例子

当您想要Invoke/BeginInvoke内联代码时,内置(2.0)MethodInvoker委托很有用.这避免了需要创建实际的委托和单独的方法.

    void FileMessageEvent(object sender, MessageEventArgs e)
    {

        if (this.InvokeRequired == true)
        {
            this.BeginInvoke((MethodInvoker)delegate { 
                     lblMessage.Text=e.Message; 
                     Application.DoEvents(); 
                 }
            ); 

        }
    }

解决了错误:"无法将匿名方法转换为'System.Delegate',因为它不是委托类型".

数组初始化而不指定数组元素类型:

var pets = new[] { "Cat", "Dog", "Bird" };

查看组件时要显示的属性设计视图中的属性:

private double _Zoom = 1;

[Category("View")]
[Description("The Current Zoom Level")]
public double Zoom
{
get { return _Zoom;}
set { _Zoom = value;}
}

使组件库的其他用户更容易.

高级调试

显示

已提到的属性DebuggerDisplay和DebuggerBrowsable控制元素的可见性和显示的文本值.简单地重写ToString()将导致调试器使用该方法的输出.

如果您想要更复杂的输出,可以使用/创建Debugger Visualizer,这里有几个示例.

罢工的儿子

Microsoft提供称为SOS的调试器扩展.这是一个非常强大(虽然经常令人困惑)的扩展,这是诊断"泄漏"的一种很好的方法,更准确地说是对不再需要的对象的不必要的引用.

用于框架源的Symbol Server

遵循这些说明将允许您逐步完成框架的某些部分的来源.

2010年的变化

Visual Studio 2010中存在一些增强功能和新功能:

调试并行任务

并行堆栈允许同时查看多个线程调用堆栈.

历史调试允许您及时查看事件和非局部变量(只要您提前启用集合).可能是对调试方式的重大改变.

您可以使用扩展方法创建委托,就好像它们是常规方法一样,从而调整this参数.例如,

static class FunnyExtension {
    public static string Double(this string str) { return str + str; }
    public static int Double(this int num) { return num + num; }
}


Func aaMaker = "a".Double;
Func doubler = FunnyExtension.Double;

Console.WriteLine(aaMaker());       //Prints "aa"
Console.WriteLine(doubler("b"));    //Prints "bb"

请注意,这不适用于扩展值类型的扩展方法; 看到这个问题.

HttpContext.Current.Server.Execute 

非常适合将HTML呈现为AJAX回调的字符串.您可以将其与组件一起使用,而不是拼凑HTML字符串片段.我能够将页面臃肿减少几百KB,几乎没有任何混乱.我用它是这样的:

Page pageHolder = new Page();
UserControl viewControl = (UserControl)pageHolder.LoadControl(@"MyComponent.ascx");
pageHolder.Controls.Add(viewControl);
StringWriter output = new StringWriter();
HttpContext.Current.Server.Execute(pageHolder, output, false);
return output.ToString();

[field: NonSerialized]
public event EventHandler Event;

这样,事件侦听器就不会被序列化.

只是[NonSerialized]不起作用,因为NonSerializedAttribute只能应用于字段.

我不认为有人提到追加？在值类型名称之后将使其可为空.

你可以做:

DateTime? date = null;

DateTime是一个结构.

Eric Lippert的四个开关怪异

使用LINQ对过去采用迭代和条件的集合进行内联工作的能力非常有价值.值得了解所有LINQ扩展方法如何帮助您的代码更加紧凑和可维护.

我喜欢

#if DEBUG
           //Code run in debugging mode

#else
           //Code run in release mode

#endif

我正在通过"Pro ASP.NET MVC框架"(APress)这本书阅读并观察到作者正在使用对我来说很陌生的Dictionary对象.

他在不使用Add()方法的情况下添加了一个新的键/值对.然后他覆盖相同的键/值对,而不必检查该键是否已存在.例如:

Dictionary nameAgeDict = new Dictionary();
nameAgeDict["Joe"] = 34;      // no error. will just auto-add key/value
nameAgeDict["Joe"] = 41;      // no error. key/value just get overwritten
nameAgeDict.Add("Joe", 30);   // ERROR! key already exists

在许多情况下,我不需要检查我的词典是否已经有一个键,我只想添加相应的键/值对(如果需要,覆盖现有的键/值对.)在此发现之前,我总是要在添加之前检查密钥是否已经存在.

不确定这个是否被提及(11页!!)

但是,OptionalField当您对将要序列化的类/对象进行版本控制时,类的属性是惊人的.

http://msdn.microsoft.com/en-us/library/ms229752(VS.80).aspx

@Brad Barker

我认为如果你必须使用可空类型,最好使用Nullable <.T>而不是问号符号.令人惊讶的是,魔法正在发生.不知道为什么有人会想要使用Nullable <.bool>.:-)

Krzysztof Cwalina(Framwork Design Guidlines的作者之一)在这里有一篇好文章:http: //blogs.msdn.com/kcwalina/archive/2008/07/16/Nullable.aspx

Mike Hadlow在Nullability Voodoo上发表了一篇不错的帖子

没有特别的顺序:

Lists<>
Mutex

Framework 3.5中的新属性定义快捷方式.

在阅读有关.NET框架开发的书中.一个很好的建议是不要使用bool打开或关闭东西,而是使用ENums.

使用ENums,您可以为自己提供一些可扩展性,而无需重写任何代码来为函数添加新功能.

想到@dp AnonCast并决定尝试一下.以下是我提出的可能对某些人有用的内容:

// using the concepts of dp's AnonCast
static Func TypeCurry(Func