我知道在C＃中使用Null合并运算符的标准方法是设置默认值。
string nobody = null;
string somebody = "Bob Saget";
string anybody = "";
anybody = nobody ?? "Mr. T"; // returns Mr. T
anybody = somebody ?? "Mr. T"; // returns "Bob Saget"但是还有什么??用呢？它看起来不像三元运算符有用，除了比以下内容更简洁和易于阅读之外：
nobody = null;
anybody = nobody == null ? "Bob Saget" : nobody; // returns Bob Saget因此，考虑到甚至更少了解空合并运算符...
你用过??别的吗？
是??必要的，还是只应使用三元运算符（大多数人都熟悉）
Answers:
好吧，首先，它比标准三元链更容易链接：
string anybody = parm1 ?? localDefault ?? globalDefault;与
string anyboby = (parm1 != null) ? parm1
: ((localDefault != null) ? localDefault
: globalDefault);如果null可能对象不是变量，它也可以很好地工作：
string anybody = Parameters["Name"]
?? Settings["Name"]
?? GlobalSetting["Name"];与
string anybody = (Parameters["Name"] != null ? Parameters["Name"]
: (Settings["Name"] != null) ? Settings["Name"]
: GlobalSetting["Name"];我将其用作延迟加载单线：
public MyClass LazyProp
{
get { return lazyField ?? (lazyField = new MyClass()); }
}可读吗？自行决定。
我发现它以两种“稍微奇怪”的方式有用：
out编写时具有参数的替代方法TryParse例程（即，如果解析失败，则返回null值）后者需要更多信息。通常，当您创建包含多个元素的比较时，您需要查看比较的第一部分（例如年龄）是否给出确定的答案，然后仅在第一部分没有帮助的情况下才能查看下一部分（例如名称）。使用空合并运算符意味着您可以编写非常简单的比较（无论是排序还是相等）。例如，在MiscUtil中使用几个辅助类：
public int Compare(Person p1, Person p2)
{
return PartialComparer.Compare(p1.Age, p2.Age)
?? PartialComparer.Compare(p1.Name, p2.Name)
?? PartialComparer.Compare(p1.Salary, p2.Salary)
?? 0;
}诚然，我现在在MiscUtil中拥有ProjectionComparer以及一些扩展，这些扩展使这种事情变得更加容易-但它仍然很整洁。
在开始执行Equals时，可以执行相同的操作来检查引用是否相等（或无效）。
另一个优点是三元运算符需要双重评估或临时变量。
考虑一下，例如：
string result = MyMethod() ?? "default value";而使用三元运算符时，您可能会遇到以下任何一种情况：
string result = (MyMethod () != null ? MyMethod () : "default value");它两次调用MyMethod，或者：
string methodResult = MyMethod ();
string result = (methodResult != null ? methodResult : "default value");无论哪种方式，空合并运算符都更干净，我想更有效。
MyMethod()有任何副作用时，它特别有用。
MyMethod()在返回值之外没有任何影响，则编译器知道不会两次调用它，因此在大多数情况下，您实际上不必担心效率。
MyMethod()点缀对象的链接序列时，它还使事物更易于阅读。例如：myObject.getThing().getSecondThing().getThirdThing()
MyMethod在这种情况下，对的两个调用是相同的，假定这MyMethod是一个纯函数。另一个选项是“自动记忆”或仅在缓存中关闭该功能。另一方面：en.wikipedia.org/wiki/Global_value_numbering
要考虑的另一件事是，合并运算符不会像三元数那样两次调用属性的get方法。
因此，在某些情况下，您不应该使用三元组，例如：
public class A
{
var count = 0;
private int? _prop = null;
public int? Prop
{
get
{
++count;
return _prop
}
set
{
_prop = value;
}
}
}如果您使用：
var a = new A();
var b = a.Prop == null ? 0 : a.Prop;getter将被调用两次，并且count变量将等于2，并且如果您使用：
var b = a.Prop ?? 0该count变量应等于1。
??是相当于到?:。
我发现??运算符的最大好处是，您可以轻松地将可为空的值类型转换为不可为空的类型：
int? test = null;
var result = test ?? 0; // result is int, not int?我经常在Linq查询中使用它：
Dictionary<int, int?> PurchaseQuantities;
// PurchaseQuantities populated via ASP .NET MVC form.
var totalPurchased = PurchaseQuantities.Sum(kvp => kvp.Value ?? 0);
// totalPurchased is int, not int?kvp == null。并且实际上Nullable<T>有一种GetValueOrDefault我通常使用的方法。
我用过?? 在我的IDataErrorInfo实现中：
public string Error
{
get
{
return this["Name"] ?? this["Address"] ?? this["Phone"];
}
}
public string this[string columnName]
{
get { ... }
}如果任何单个属性都处于“错误”状态，则会收到该错误，否则将返回null。真的很好。
this["Name"]，this["Address"]等等？
我喜欢使用null合并运算符来延迟加载某些属性。
一个非常简单（人为设计）的例子只是为了说明我的观点：
public class StackOverflow
{
private IEnumerable<string> _definitions;
public IEnumerable<string> Definitions
{
get
{
return _definitions ?? (
_definitions = new List<string>
{
"definition 1",
"definition 2",
"definition 3"
}
);
}
}
}是?? 必要，还是只应使用三元运算符（大多数人都熟悉）
其实，我的经验是，所有的人太少熟悉的三元操作符（或者更准确地说，在有条件的经营者，?:是“三元”在同一意义上||是二进制或+是一元或二元；但是碰巧是仅是多种语言中的三元运算符），因此至少在该有限示例中，您的语句就此失败。
另外，如前所述，在一种主要情况下，空合并运算符非常有用，也就是说，每当要求值的表达式有任何副作用时。在这种情况下，您必须先使用（a）引入临时变量，或者（b）更改应用程序的实际逻辑，才能使用条件运算符。（b）显然在任何情况下都不适合，虽然这是个人喜好，但我不喜欢在声明范围内添加很多无关紧要的变量，即使是短暂的变量也是如此，因此（a）也不适合特定情况。
当然，如果您需要对结果进行多次检查，则条件运算符或一组if块可能是完成此工作的工具。但是对于简单的“如果它为null，则使用它，否则使用它”，null合并运算符??是完美的。
唯一的问题是null-coalesce运算符不会检测到空字符串。
即
string result1 = string.empty ?? "dead code!";
string result2 = null ?? "coalesced!";输出：
result1 = "" result2 = coalesced!
我目前正在研究覆盖?? 操作员来解决此问题。将其内置到框架中肯定很方便。
有什么想法吗？
??不能重载：msdn.microsoft.com/zh-cn/library/8edha89s(v=vs.100).aspx-拥有重载性将是一个很好的选择。我使用一个组合：s1.Nullify() ?? s2.Nullify()在字符串为空的情况下，其中string Nullify(this s)返回null。
凉！算我一个不了解null合并运算符的人-这真是太漂亮了。
我发现它比三元运算符更容易阅读。
我想到的第一个可能使用的地方是将所有默认参数都放在一个地方。
public void someMethod( object parm2, ArrayList parm3 )
{
someMethod( null, parm2, parm3 );
}
public void someMethod( string parm1, ArrayList parm3 )
{
someMethod( parm1, null, parm3 );
}
public void someMethod( string parm1, object parm2, )
{
someMethod( parm1, parm2, null );
}
public void someMethod( string parm1 )
{
someMethod( parm1, null, null );
}
public void someMethod( object parm2 )
{
someMethod( null, parm2, null );
}
public void someMethod( ArrayList parm3 )
{
someMethod( null, null, parm3 );
}
public void someMethod( string parm1, object parm2, ArrayList parm3 )
{
// Set your default parameters here rather than scattered through the above function overloads
parm1 = parm1 ?? "Default User Name";
parm2 = parm2 ?? GetCurrentUserObj();
parm3 = parm3 ?? DefaultCustomerList;
// Do the rest of the stuff here
}有点奇怪的用例，但是我有一种方法，其中一个IDisposable对象可能作为arg传递（并因此由父对象传递），但也可能为null（因此应在本地方法中创建和处置）
要使用它，代码要么看起来像
Channel channel;
Authentication authentication;
if (entities == null)
{
using (entities = Entities.GetEntities())
{
channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
[...]
}
}
else
{
channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
[...]
}但是在零合并的情况下变得更加整洁
using (entities ?? Entities.GetEntities())
{
channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
[...]
}我已经这样使用：
for (int i = 0; i < result.Count; i++)
{
object[] atom = result[i];
atom[3] = atom[3] ?? 0;
atom[4] = atom[4] != null ? "Test" : string.Empty;
atom[5] = atom[5] ?? "";
atom[6] = atom[6] ?? "";
atom[7] = atom[7] ?? "";
atom[8] = atom[8] ?? "";
atom[9] = atom[9] ?? "";
atom[10] = atom[10] ?? "";
atom[12] = atom[12] ?? false;
}