Environment.NewLine

对于独立于系统的换行符。

下面是我最近发现的一个有用的：

Microsoft.VisualBasic.Logging.FileLogTraceListener

MSDN链接

这是一个TraceListener实现，它有很多功能，例如自动日志文件回滚，我以前会使用自定义日志框架。好的是，它是.NET的核心部分，并与Trace框架集成，因此易于立即获取和使用。

这是“隐藏的”，因为它在Microsoft.VisualBasic程序集中。。。但您也可以从C#中使用它。

很抱歉这么晚才发布，我是Stack Overflow的新手，因此错过了之前的机会。

我发现EventHandler＜T＞是该框架的一个很好的功能，但未得到充分利用。

我遇到的大多数C#开发人员在定义自定义事件时仍然会定义自定义事件处理程序委托，这不再是必要的。

而不是：

public delegate void MyCustomEventHandler(object sender, MyCustomEventArgs e);

public class MyCustomEventClass 
{
    public event MyCustomEventHandler MyCustomEvent;
}

你可以去：

public class MyCustomEventClass 
{
    public event EventHandler<MyCustomEventArgs> MyCustomEvent;
}

这要简洁得多，而且您不会陷入这样的两难境地：是将委托放在包含事件的类的.cs文件中，还是EventArgs派生类中。

我最喜欢的属性：InternalsVisibleTo

在程序集级别，您可以声明另一个程序集可以看到您的内部构件。出于测试目的，这绝对是美妙的。

将其粘贴到AssemblyInfo.cs或等效程序中，测试程序集就可以完全访问所有需要测试的内部内容。

[assembly: InternalsVisibleTo("MyLibrary.Test, PublicKey=0024...5c042cb")]

如您所见，测试程序集必须具有强名称才能获得被测试程序集的信任。

在.Net Framework 2.0+、Compact Framework 2.0+和XNA Framework 1.0+中提供。

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

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

变成

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

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

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();
        }
    }
}