关于帖子w/perma链接“隐藏的C#特性？”，还有另一种方法可以实现同样的效果-缩进/换行。看看这个。。

XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.NewLineOnAttributes = true;
xmlWriterSettings.Indent = true;


XmlWriter xml = XmlWriter.Create(@"C:\file.xml", xmlWriterSettings);

// Start writing the data using xml.WriteStartElement(), xml.WriteElementString(...), xml.WriteEndElement() etc

我不确定这是否是一个未知的特性！

工厂方法的类型推断

我不知道这是否已经发布（我扫描了第一篇帖子，找不到）。

这最好用一个例子来说明，假设你有这个类（模拟一个元组），在中，为了演示使这成为可能的所有语言特性，我将一步一步地学习。

public class Tuple<V1, V2> : Tuple
{
    public readonly V1 v1;
    public readonly V2 v2;

    public Tuple(V1 v1, V2 v2)
    {
      this.v1 = v1;
      this.v2 = v2;
    }
}

每个人都知道如何创建它的实例，例如：

Tuple<int, string> tup = new Tuple<int, string>(1, "Hello, World!");

不完全是火箭科学，现在我们当然可以将变量的类型声明更改为var，如下所示：

var tup = new Tuple<int, string>(1, "Hello, World!");

众所周知，这里有一个带类型参数的静态方法，每个人都应该熟悉：

public static void Create<T1, T2>()
{
    // stuff
}

这也是众所周知的，是这样做的：

Create<float, double>();

大多数人不知道的是，如果泛型方法的参数包含它所需的所有类型，则可以推断它们，例如：

public static void Create<T1, T2>(T1 a, T2 b)
{
    // stuff
}

这两个调用是相同的：

Create<float, string>(1.0f, "test");
Create(1.0f, "test");

因为T1和T2是从传递的参数推断出来的。将这些知识与var关键字相结合，我们可以通过添加第二个静态类和静态方法，例如：

public abstract class Tuple
{
    public static Tuple<V1, V2> Create<V1, V2>(V1 v1, V2 v2)
    {
        return new Tuple<V1, V2>(v1, v2);
    }
}

实现此效果：

var tup = Tuple.Create(1, "Hello, World!");

这意味着：变量“tup”的类型、类型参数“Create”和返回值“Create”都是从作为参数传递给Create的类型中推断出来的

完整代码如下所示：

public abstract class Tuple
{
    public static Tuple<V1, V2> Create<V1, V2>(V1 v1, V2 v2)
    {
        return new Tuple<V1, V2>(v1, v2);
    }
}

public class Tuple<V1, V2> : Tuple
{
    public readonly V1 v1;
    public readonly V2 v2;

    public Tuple(V1 v1, V2 v2)
    {
        this.v1 = v1;
        this.v2 = v2;
    }
}

// Example usage:
var tup = Tuple.Create(1, "test");

这为您提供了随处可见的完全类型推断工厂方法！

我喜欢使用using指令重命名一些类，以便于阅读，如下所示：

// defines a descriptive name for a complexed data type
using MyDomainClassList = System.Collections.Generic.List<
  MyProjectNameSpace.MyDomainClass>;

....


MyDomainClassList myList = new MyDomainClassList();
/* instead of 
List<MyDomainClass> myList = new List<MyDomainClass>();
*/

这对于代码维护也非常方便。如果需要更改类名，只需要更改一个位置。另一个例子：

using FloatValue  = float; // you only need to change it once to decimal, double...

....
FloatValue val1;
...

定义自定义属性时，可以将其与[MyAttrAttribute]或[MyAttr]一起使用。当两种书写都存在类时，就会发生编译错误。

@特殊字符可用于区分它们：

[AttributeUsage(AttributeTargets.All)]
public class X: Attribute
{}

[AttributeUsage(AttributeTargets.All)]
public class XAttribute: Attribute
{}

[X]      // Error: ambiguity
class Class1 {}

[XAttribute]   // Refers to XAttribute
class Class2 {}

[@X]      // Refers to X
class Class3 {}

[@XAttribute]   // Refers to XAttribute
class Class4 {}

仅适用于使用扩展方法的引用枚举二进制操作。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace BinaryOpGenericTest
{
    [Flags]
    enum MyFlags
    {
        A = 1,
        B = 2,
        C = 4

    }

    static class EnumExtensions
    {
        private static Dictionary<Type, Delegate> m_operations = new Dictionary<Type, Delegate>();

        public static bool IsFlagSet<T>(this T firstOperand, T secondOperand) 
                                                  where T : struct
        {

            Type enumType = typeof(T);


            if (!enumType.IsEnum)
            {
                throw new InvalidOperationException("Enum type parameter required");
            }


            Delegate funcImplementorBase = null;
            m_operations.TryGetValue(enumType, out funcImplementorBase);

            Func<T, T, bool> funcImplementor = funcImplementorBase as Func<T, T, bool>;

            if (funcImplementor == null)
            {
                funcImplementor = buildFuncImplementor(secondOperand);
            }



            return funcImplementor(firstOperand, secondOperand);
        }


        private static Func<T, T, bool> buildFuncImplementor<T>(T val)
                                                            where T : struct
        {
            var first = Expression.Parameter(val.GetType(), "first");
            var second = Expression.Parameter(val.GetType(), "second");

            Expression convertSecondExpresion = Expression.Convert(second, typeof(int));
            var andOperator = Expression.Lambda<Func<T, T, bool>>(Expression.Equal(
                                                                                                       Expression.And(
                                                                                                            Expression.Convert(first, typeof(int)),
                                                                                                             convertSecondExpresion),
                                                                                                       convertSecondExpresion),
                                                                                             new[] { first, second });
            Func<T, T, bool> andOperatorFunc = andOperator.Compile();
            m_operations[typeof(T)] = andOperatorFunc;
            return andOperatorFunc;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            MyFlags flag = MyFlags.A | MyFlags.B;

            Console.WriteLine(flag.IsFlagSet(MyFlags.A));            
            Console.WriteLine(EnumExtensions.IsFlagSet(flag, MyFlags.C));
            Console.ReadLine();
        }
    }
}

连接？到一个类型可为null，例如：int？“c:\dir”而不是@“c:\dir”