C#的隐藏特性？ [关闭]

Question

从this question 了解到以下内容后，我想到了这一点：

where T : struct

我们，C# 开发人员，都知道 C# 的基础知识。我的意思是声明、条件、循环、运算符等。

我们中的一些人甚至掌握了诸如Generics、anonymous types、lambdas、LINQ、...之类的东西。

但 C# 最隐秘的特性或技巧是什么，即使是 C# 爱好者、瘾君子、专家也几乎不知道？

以下是目前已揭示的功能：

关键词

• yieldMichael Stum
• varMichael Stum
• using()kokos声明
• readonlykokos
• asMike Stone
• as / is Ed Swangren
• as / is（改进）Rocketpants
• defaultdeathofrats
• global::pzycoman
• using() 阻止 AlexCuse
• volatileJakub Šturc
• extern aliasJakub Šturc

属性

• DefaultValueAttributeMichael Stum
• ObsoleteAttributeDannySmurf
• DebuggerDisplayAttributeStu
• DebuggerBrowsable 和 DebuggerStepThrough bdukes
• ThreadStaticAttributemarxidad
• FlagsAttributeMartin Clarke
• ConditionalAttributeAndrewBurns

语法

• ?? (coalesce nulls) operator by kokos
• Nick Berardi 的编号标记
• where T:newLars Mæhlum
• Keith 的隐式泛型
• Keith 的单参数 lambda
• Keith 的自动属性
• Keith 的命名空间别名
• Patrick 带有 @ 的逐字字符串文字
• enum 值lfoust
• @variablenames by marxidad
• event 运营商marxidad
• 用Portman格式化字符串括号
• xanadont 的属性访问器可访问性修饰符
• 条件（三元）运算符 (?:) by JasonS
• checked 和 unchecked 运算符由 Binoj Antony
• implicit and explicit 运营商Flory

语言特点

• Brad Barker 的可空类型
• Keith 的匿名类型
• __makeref __reftype __refvalueJudah Himango
• 对象初始化器lomaxx
• 用David in Dakota格式化字符串
• marxidad 的扩展方法
• partialJon Erickson 的方法
• John Asbeck 的预处理器指令
• DEBUG Robert Durgin 的预处理器指令
• SefBkn 导致运算符重载
• chakrit 的类型推断
• 布尔运算符taken to next level by Rob Gough
• 通过Roman Boiko将值类型变量作为接口传递而不装箱
• 通过Roman Boiko 以编程方式确定声明的变量类型
• Chris 的静态构造函数
• roosteronacid 使用 LINQ 使用 LINQ 更容易上手/精简 ORM 映射
• __arglistZac Bowling

Visual Studio 功能

• 在编辑器中选择文本块Himadri
• DannySmurf 的片段

框架

• TransactionScopeKiwiBastard
• DependantTransactionKiwiBastard
• Nullable<T>IainMH
• MutexDiago
• System.IO.Pathageektrapped
• WeakReferenceJuan Manuel

方法和属性

• String.IsNullOrEmpty() 方法KiwiBastard
• List.ForEach() 方法KiwiBastard
• BeginInvoke(), EndInvoke() 方法由 Will Dean
• Nullable<T>.HasValue 和 Nullable<T>.Value 属性由 Rismo
• GetValueOrDefault 方法John Sheehan

提示和技巧

• Andreas H.R. Nilsson 的事件处理程序的好方法
• John 的大写比较
• 通过dp 访问匿名类型而不进行反射
• Will 懒惰实例化集合属性的快速方法
• roosteronacid 的类似 JavaScript 的匿名内联函数

其他

• kokos 的网络模块
• LINQBridgeDuncan Smart
• Parallel ExtensionsJoel Coehoorn

Answer 1

lambdas 和类型推断 被低估了。 Lambda 可以有多个语句，它们会自动兼作兼容的委托对象（只需确保签名匹配），如下所示：

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

请注意，我没有new CancellationEventHandler，也不必指定sender 和e 的类型，它们可以从事件中推断出来。这就是为什么编写整个delegate (blah blah) 不那么麻烦的原因，这还需要您指定参数类型。

Lambda 不需要返回任何内容，并且类型推断在这样的上下文中非常强大。

顺便说一句，在函数式编程的意义上，您总是可以返回 制作 Lambda 的 Lambda。例如，这里有一个 lambda，它生成一个处理 Button.Click 事件的 lambda：

Func<int, int, EventHandler> makeHandler =
    (dx, dy) => (sender, e) => {
        var btn = (Button) sender;
        btn.Top += dy;
        btn.Left += dx;
    };

btnUp.Click += makeHandler(0, -1);
btnDown.Click += makeHandler(0, 1);
btnLeft.Click += makeHandler(-1, 0);
btnRight.Click += makeHandler(1, 0);

注意链接：(dx, dy) => (sender, e) =>

这就是我很高兴参加函数式编程课程的原因:-)

除了 C 语言中的指针，我认为这是你应该学习的另一个基本知识 :-)

Answer 2

几乎所有酷的都被提及了。不确定这个是否众所周知

C# 属性/字段构造函数初始化：

var foo = new Rectangle() 
{ 
    Fill = new SolidColorBrush(c), 
    Width = 20, 
    Height = 20 
};

这将创建矩形，并设置列出的属性。

我注意到一些有趣的事情 - 您可以在属性列表的末尾添加一个逗号，而不会出现语法错误。所以这也是有效的：

var foo = new Rectangle() 
{ 
    Fill = new SolidColorBrush(c), 
    Width = 20, 
    Height = 20,
};

Answer 3

Conditional string.Format:

根据数字是正数、负数还是零，对数字应用不同的格式。

string s = string.Format("{0:positive;negative;zero}", i);

例如

string format = "000;-#;(0)";

string pos = 1.ToString(format);     // 001
string neg = (-1).ToString(format);  // -1
string zer = 0.ToString(format);     // (0)

Answer 4

您可以组合protected 和internal 访问器，使其在同一个程序集中公开，但在不同程序集中受到保护。这可以用于字段、属性、方法甚至常量。

Answer 5

我想如果你必须使用 nullable 类型，最好使用 Nullable<.t> 而不是问号 符号。让人眼花缭乱 很明显，魔法正在发生。不是 确定为什么有人会想要使用 可空<.bool>。

在 VB.NET Web 服务中，参数可能无法通过（因为合作伙伴的请求不一致或不可靠），但必须通过针对建议类型的验证 （“如果是搜索请求”的布尔值）。把它归结为“管理层的另一个要求”......

...是的，我知道有些人认为这不是做这些事情的正确方法，但是 IsSearchRequest As Nullable(Of Boolean) 让我那天晚上失去了理智！

Answer 6

P/Invoke 的大部分内容都有些奇怪。

属性示例：

[DllImport ("gdi32.dll")] 
[return : MarshalAs(UnmanagedType.I4)]
[StructLayout(LayoutKind.Sequential)]

Answer 7

其他一切，加上

1) 隐式泛型（为什么只在方法上而不在类上？）

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2) 带有一个参数的简单 lambda：

x => x.ToString() //simplify so many calls

3) 匿名类型和初始化器：

//Duck-typed: works with any .Add method.
var colours = new Dictionary<string, string> {
    { "red", "#ff0000" },
    { "green", "#00ff00" },
    { "blue", "#0000ff" }
};

int[] arrayOfInt = { 1, 2, 3, 4, 5 };

---

另一个：

4) 自动属性可以有不同的作用域：

public int MyId { get; private set; }

---

感谢@pzycoman 提醒我：

5) 命名空间别名（并不是说您可能需要这种特殊的区别）：

using web = System.Web.UI.WebControls;
using win = System.Windows.Forms;

web::Control aWebControl = new web::Control();
win::Control aFormControl = new win::Control();

Answer 8

您可以使用{ } 括号来限制变量的生命周期和范围。

{
    string test2 = "3";
    Console.Write(test2);
}

Console.Write(test2); //compile error

test2 只存在于括号内。

Answer 9

许多人没有意识到他们可以使用 OrdinalIgnoreCase 来比较字符串，而不必执行 someString.ToUpper()。这消除了额外的字符串分配开销。

if( myString.ToUpper() == theirString.ToUpper() ){ ... }

变成

if( myString.Equals( theirString, StringComparison.OrdinalIgnoreCase ) ){ ... }

Answer 10

您输入“prop”，然后按 [TAB] 两次，它会为您的属性生成有用的代码并可以加快您的输入速度。

我知道这在 VS 2005 中有效（我使用它），但我不知道在以前的版本中。

Answer 11

C# + CLR：

1. Thread.MemoryBarrier: 大多数人不会用它，而且 MSDN 上有一些不准确的信息。但是，如果您知道intricacies，那么您可以进行漂亮的无锁同步。

2. volatile, Thread.VolatileRead, Thread.VolatileWrite: 很少有人会使用这些，了解他们避免和引入的所有风险的人就更少了:)。

3. ThreadStatic变量：前几年只有一种情况我发现ThreadStatic变量绝对是天赐良机，不可或缺。例如，当您想为整个调用链做某事时，它们非常有用。

4. fixed 关键字：当您希望访问大型数组的元素几乎与 C++ 一样快时，这是一个隐藏的武器（默认情况下，C# 强制执行绑定检查，这会减慢速度）。

   李>

5. default(typeName) 关键字也可以在泛型类之外使用。创建结构的空副本很有用。

6. 我使用的一个方便的功能是DataRow[columnName].ToString() 总是返回非空值。如果数据库中的值为 NULL，则得到空字符串。

7. 即使她/他没有启用异常自动中断，您也可以在需要开发人员注意时使用 Debugger 对象自动中断：

#if DEBUG  
    if (Debugger.IsAttached)  
        Debugger.Break();  
#endif

8. 您可以为复杂难看的泛型类型设置别名，这样您就不必一次又一次地复制粘贴它们。您也可以在一处更改该类型。例如，

    using ComplicatedDictionary = Dictionary<int, Dictionary<string, object>>;
    ComplicatedDictionary myDictionary = new ComplicatedDictionary();

Answer 12

以下是一些有趣的隐藏 C# 功能，以未记录的 C# 关键字的形式：

__makeref

__reftype

__refvalue

__arglist

这些是未记录的 C# 关键字（甚至 Visual Studio 也能识别它们！），它们被添加到泛型之前用于更有效的装箱/拆箱。它们与 System.TypedReference 结构协同工作。

还有__arglist，用于变长参数列表。

人们不太了解的一件事是System.WeakReference——一个非常有用的类，它跟踪对象但仍允许垃圾收集器收集它。

最有用的“隐藏”功能是 yield return 关键字。它并不是真正隐藏的，但很多人并不知道它。 LINQ 建立在此之上；它允许通过在后台生成状态机来延迟执行查询。 Raymond Chen 最近发布了关于internal, gritty details。

Answer 13

关于foreach：它不使用“鸭子打字”，因为鸭子打字IMO指的是运行时检查。它在编译时使用结构类型检查（与标称相对）来检查类型中所需的方法。

Answer 14

我喜欢在如下列表中查找内容：-

bool basketContainsFruit(string fruit) {
  return new[] { "apple", "orange", "banana", "pear" }.Contains(fruit);
}

而不是：-

bool basketContainsFruit(string fruit) {
  return fruit == "apple" || fruit == "orange" || fruit == "banana" ||
    fruit == "pear";
}

在实践中并没有那么多，但是将项目与搜索主题进行匹配的想法确实非常有用 + 简洁。

Answer 15

我参加这个聚会迟到了，所以我的第一选择已经做出。但我还没有看到有人提到这个宝石：

Parallel Extensions to the .NET Framework

它有一些东西，比如用 Parallel.For 替换或用 Parallel.ForEach 替换 foreach

---

平行样本：
在您看来，一秒钟可以创建多少个 CLR 对象？
请看下面的例子：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ObjectInitSpeedTest
{
   class Program
   {
       //Note: don't forget to build it in Release mode.
       static void Main()
       {
           normalSpeedTest();           
           parallelSpeedTest();

           Console.ForegroundColor = ConsoleColor.White;
           Console.WriteLine("Press a key ...");
           Console.ReadKey();
       }

       private static void parallelSpeedTest()
       {
           Console.ForegroundColor = ConsoleColor.Yellow;
           Console.WriteLine("parallelSpeedTest");

           long totalObjectsCreated = 0;
           long totalElapsedTime = 0;

           var tasks = new List<Task>();
           var processorCount = Environment.ProcessorCount;

           Console.WriteLine("Running on {0} cores", processorCount);

           for (var t = 0; t < processorCount; t++)
           {
               tasks.Add(Task.Factory.StartNew(
               () =>
               {
                   const int reps = 1000000000;
                   var sp = Stopwatch.StartNew();
                   for (var j = 0; j < reps; ++j)
                   {
                       new object();
                   }
                   sp.Stop();

                   Interlocked.Add(ref totalObjectsCreated, reps);
                   Interlocked.Add(ref totalElapsedTime, sp.ElapsedMilliseconds);
               }
               ));
           }

           // let's complete all the tasks
           Task.WaitAll(tasks.ToArray());

           Console.WriteLine("Created {0:N} objects in 1 sec\n", (totalObjectsCreated / (totalElapsedTime / processorCount)) * 1000);
       }

       private static void normalSpeedTest()
       {
           Console.ForegroundColor = ConsoleColor.Green;
           Console.WriteLine("normalSpeedTest");

           const int reps = 1000000000;
           var sp = Stopwatch.StartNew();
           sp.Start();
           for (var j = 0; j < reps; ++j)
           {
               new object();
           }
           sp.Stop();

           Console.WriteLine("Created {0:N} objects in 1 sec\n", (reps / sp.ElapsedMilliseconds) * 1000);
       }
   }
}

Answer 16

我最喜欢的是

global::

使用我们的一些 3rd 方代码提供程序来逃离命名空间地狱的关键字...

例子：

global::System.Collections.Generic.List<global::System.String> myList =
    new global::System.Collections.Generic.List<global::System.String>();

Answer 17

1. 我还不能发表评论，但请注意，默认情况下 Visual Studio 2008 会自动跳过属性，因此在这种情况下不再需要 DebuggerStepThrough 属性。

2. 另外，我没有注意到有人展示了如何声明一个无参数的 lambda（对于实现 Action 很有用）

   () => DoSomething(x);

您还应该阅读闭包 - 我不够聪明，无法正确解释它们。但基本上这意味着编译器做了一些聪明的事情，所以即使在创建 lambda 之后它“超出范围”，那行代码中的 x 仍然可以工作。

1. 我最近还发现你可以假装忽略一个 lambda 参数：

   (e, _) => DoSomething(e)

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

Answer 18

我经常遇到需要将通用参数对象持久化到基类的视图状态中。

public abstract class BaseListControl<ListType,KeyType,ParameterType>
                 : UserControl 
                 where ListType : BaseListType
                 && ParameterType : BaseParameterType, new
{

    private const string viewStateFilterKey = "FilterKey";

    protected ParameterType Filters
    {
        get
        {
            if (ViewState[viewStateFilterKey] == null)
                ViewState[viewStateFilterKey]= new ParameterType();

            return ViewState[viewStateFilterKey] as ParameterType;
        }
        set
        {
            ViewState[viewStateFilterKey] = value;
        }
    }

}

用法：

private void SomeEventHappened(object sender, EventArgs e)
{
    Filters.SomeValue = SomeControl.SelectedValue;
}

private void TimeToFetchSomeData()
{
    GridView.DataSource = Repository.GetList(Filters);
}

“where ParameterType : BaseParameterType, new”这个小技巧使它真正起作用。

在我的基类中使用这个属性，我可以自动处理分页、设置过滤器值以过滤网格视图、使排序变得非常容易等等。

我真的只是说泛型在坏人手中可能是一个非常强大的野兽。

Answer 19

老实说，根据定义，专家应该知道这些东西。但要回答您的问题：Built-In Types Table (C# Reference)

数字的编译器标记因这些而广为人知：

Decimal = M
Float = F
Double = D

// for example
double d = 30D;

但是这些比较模糊：

Long = L
Unsigned Long = UL
Unsigned Int = U

Answer 20

我个人最喜欢的两个，我认为很少使用：

1. 片段（尤其是属性，在 Visual Studio 2008 中做得更好）
2. ObsoleteAttribute

Answer 21

“yield”会出现在我的脑海中。 [DefaultValue()] 等一些属性也是我的最爱。

“var”关键字比较知名，但您也可以在 .NET 2.0 应用程序中使用它（只要您use the .NET 3.5 compiler 并将其设置为输出 2.0 代码）似乎不是众所周知。

编辑：kokos，感谢您指出 ??运营商，确实很有用。由于搜索它有点困难（因为 ?? 只是被忽略了），这里是该运算符的 MSDN 文档页面：?? Operator (C# Reference)

Answer 22

混音。基本上，如果您想为多个类添加一个特性，但不能为所有类使用一个基类，则让每个类实现一个接口（没有成员）。然后，为接口写一个扩展方法，即

public static DeepCopy(this IPrototype p) { ... }

当然，牺牲了一些清晰度。但它有效！

Answer 23

类似 JavaScript 的匿名内联函数

返回一个字符串：

var s = new Func<String>(() =>
{
    return "Hello World!";
})();

返回一个更复杂的对象：

var d = new Func<Dictionary<Int32, String>>(() =>
{
    return new Dictionary<Int32, String>
    {
        { 0, "Foo" },
        { 1, "Bar" },
        { 2, "..." }
    };
})();

一个真实的用例：

var tr = new TableRow();

tr.Cells.AddRange
(
    new[]
    {
        new TableCell { Text = "" },
        new TableCell { Text = "" },
        new TableCell { Text = "" },

        new TableCell
        {
            Text = new Func<String>(() =>
            {
                return @"Result of a chunk of logic, without having to define
                         the logic outside of the TableCell constructor";
            })()
        },

        new TableCell { Text = "" },
        new TableCell { Text = "" }
    }
);

注意：不能在内联函数的范围内重复使用变量名。

替代语法

// The one-liner
Func<Int32, Int32, String> Add = (a, b) => Convert.ToString(a + b);

// Multiple lines
Func<Int32, Int32, String> Add = (a, b) =>
{
    var i = a + b;

    return i.ToString();
};

// Without parameters
Func<String> Foo = () => "";

// Without parameters, multiple lines
Func<String> Foo = () =>
{
    return "";
};

缩短字符串并添加水平省略号...

Func<String, String> Shorten = s => s.Length > 100 ? s.Substring(0, 100) + "&hellip;" : s;

Answer 24

我会说使用某些系统类作为扩展方法非常方便，例如 System.Enum，您可以执行以下操作...

[Flags]
public enum ErrorTypes : int {
    None = 0,
    MissingPassword = 1,
    MissingUsername = 2,
    PasswordIncorrect = 4
}

public static class EnumExtensions {

    public static T Append<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType) type | (int)(ValueType) value));
    }

    public static T Remove<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType)type & ~(int)(ValueType)value));
    }

    public static bool Has<T> (this System.Enum type, T value) where T : struct
    {
        return (((int)(ValueType)type & (int)(ValueType)value) == (int)(ValueType)value);
    }

}

...

//used like the following...

ErrorTypes error = ErrorTypes.None;
error = error.Append(ErrorTypes.MissingUsername);
error = error.Append(ErrorTypes.MissingPassword);
error = error.Remove(ErrorTypes.MissingUsername);

//then you can check using other methods
if (error.Has(ErrorTypes.MissingUsername)) {
    ...
}

这当然只是一个例子 - 这些方法可能需要更多的工作......

Answer 25

从方法返回匿名类型并在不反射的情况下访问成员。

// Useful? probably not.
private void foo()
{
    var user = AnonCast(GetUserTuple(), new { Name = default(string), Badges = default(int) });
    Console.WriteLine("Name: {0} Badges: {1}", user.Name, user.Badges);
}

object GetUserTuple()
{
    return new { Name = "dp", Badges = 5 };
}    

// Using the magic of Type Inference...
static T AnonCast<T>(object obj, T t)
{
   return (T) obj;
}

Answer 26

我喜欢滥用静态模板类不共享其静态成员这一事实。

当Type 实例在编译时已知时，这是任何Dictionary<Type,...> 的线程安全（在创建时）和廉价替代品。

public static class MyCachedData<T>{
    static readonly CachedData Value;
    static MyCachedData(){
       Value=// Heavy computation, such as baking IL code or doing lots of reflection on a type
    }
}

干杯， 弗洛里安

Answer 27

另一种通过 yield 获取 IEnumerable 而不显式创建 IEnumerable 对象的方法

public IEnumerable<Request> SomeMethod(IEnumerable<Request> requests)
{
    foreach (Request request in requests)
       yield return DoSomthing(request);
}

Answer 28

在验证用户输入时，每种原始类型的 TryParse 方法都很棒。

double doubleValue
if (!Double.TryParse(myDataRow("myColumn"), out doubleValue))
{
    // set validation error
}

Answer 29

我在这次谈话中有点晚了，我想贡献以下内容。对于一些开发者来说，这可能是一个新事物。

public class User
{
    public long UserId { get; set; }
    public String Name { get; set; }
    public String Password { get; set; }
    public String Email { get; set; }
}

声明和初始化它的常用方法是使用构造函数或类似的方法。

User user = new User();
user.UserId = 1;
user.Name = "myname";
etc

但我学会了以下方法来初始化它。我知道 Visual Basic 开发人员会喜欢它，因为它就像操作符仅在 VB.NET 中可用，而在 C# 中不可用，如下所示。

User user = new User()
{
    UserId = 1,
    Name = "myname",
    Email = "myemail@domain.com",
    Password = "mypassword"
};

Answer 30

我喜欢的几件事：

-如果你创建一个类似于

的界面

 public interface SomeObject<T> where T : SomeObject<T>, new()

你强制从这个接口继承的任何东西 包含一个无参数的构造函数。这对于一个非常有用的 我遇到了几件事。

-使用匿名类型动态创建有用的对象：

var myAwesomeObject = new {Name="Foo", Size=10};

-最后，许多 Java 开发人员都熟悉如下语法：

public synchronized void MySynchronizedMethod(){}

但是，在 C# 中，这不是有效的语法。解决方法是一个方法属性：

 [MethodImpl(MethodImplOptions.Synchronized)]
 public void MySynchronizedMethod(){}