Null Coalescing 연산자를 사용하는 고유 한 방법

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

따라서 null 병합 연산자에 대한 지식조차도 적습니다 ...

• ??다른 용도로 사용해 보셨습니까 ?

• 가 ??필요, 또는 당신은 (가장 잘 알고있는 것으로) 삼항 연산자를 사용한다

우선, 표준 삼항보다 체인을 연결하는 것이 훨씬 쉽습니다.

string anybody = parm1 ?? localDefault ?? globalDefault;

vs.

string anyboby = (parm1 != null) ? parm1 
               : ((localDefault != null) ? localDefault 
               : globalDefault);

null 가능 객체가 변수가 아닌 경우에도 잘 작동합니다.

string anybody = Parameters["Name"] 
              ?? Settings["Name"] 
              ?? GlobalSetting["Name"];

vs.

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를 구현할 때 참조 동등성 (또는 nullity)을 검사하기 위해 동일한 작업을 수행 할 수 있습니다.

또 다른 장점은 삼항 연산자에 이중 평가 또는 임시 변수가 필요하다는 것입니다.

예를 들어 다음을 고려하십시오.

string result = MyMethod() ?? "default value";

삼항 연산자를 사용하면 다음 중 하나가 남습니다.

string result = (MyMethod () != null ? MyMethod () : "default value");

MyMethod를 두 번 호출하거나

string methodResult = MyMethod ();
string result = (methodResult != null ? methodResult : "default value");

어느 쪽이든, null 병합 연산자는 더 깨끗하고 더 효율적이라고 생각합니다.

고려해야 할 또 다른 사항은 통합 연산자는 삼항처럼 속성의 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에 해당 될 것입니다.

??연산자 에게 가장 큰 장점은 nullable 값 형식을 nullable이 아닌 형식으로 쉽게 변환 할 수 있다는 것입니다.

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?

내가 사용 했어 ?? 내 IDataErrorInfo 구현에서 :

public string Error
{
    get
    {
        return this["Name"] ?? this["Address"] ?? this["Phone"];
    }
}

public string this[string columnName]
{
    get { ... }
}

개별 속성이 "오류"상태 인 경우 해당 오류가 발생하고 그렇지 않으면 null이 발생합니다. 정말 잘 작동합니다.

선택적 매개 변수가 설정되지 않은 경우를 처리하기 위해 null 병합 연산자를 사용하여 조금 더 깔끔하게 만들 수 있습니다.

public void Method(Arg arg = null)
{
    arg = arg ?? Arg.Default;
    ...

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

?? 필요하거나 삼항 연산자를 사용해야합니까 (대부분 익숙한)

실제로, 내 경험에 따르면 너무 적은 수의 사람들이 삼항 연산자 (또는 더 정확하게는 조건부 연산자; 이진 또는 이진 또는 이진 ?:과 같은 의미에서 "삼항")에 익숙 합니다. 여러 언어로 된 삼항 연산자 만) 적어도 제한된 샘플에서는 진술이 실패합니다.||+

또한 앞에서 언급했듯이 null 병합 연산자가 매우 유용하고 평가할 식에 부작용이 생길 때 중요한 상황이 하나 있습니다. 이 경우에는 할 수 없습니다 (a) 임시 변수를 도입하거나 (b) 응용 프로그램의 실제 논리를 변경하지 않으면 조건부 연산자를 사용할 . (b) 어떤 상황에서도 분명히 적절하지 않으며 개인적인 취향이지만, 단기 변수가 있더라도 외부 적으로 많은 선언문을 어지럽히는 것을 좋아하지 않으므로 (a)도 마찬가지입니다. 특정 시나리오.

물론 결과에 대해 여러 번 점검해야하는 경우 조건부 연산자 또는 if블록 세트가 작업의 도구 일 수 있습니다. 그러나 간단한 "이것이 null이면 그것을 사용하고 그렇지 않으면 그것을 사용하십시오", null 병합 연산자 ??는 완벽합니다.

최근에 많이 해왔 던 한 가지는 백업에 null 병합을 사용하는 것 as입니다. 예를 들면 다음과 같습니다.

object boxed = 4;
int i = (boxed as int?) ?? 99;

Console.WriteLine(i); // Prints 4

또한 ?.각각 실패 할 수있는 긴 체인을 백업하는 데 유용합니다.

int result = MyObj?.Prop?.Foo?.Val ?? 4;
string other = (MyObj?.Prop?.Foo?.Name as string)?.ToLower() ?? "not there";

유일한 문제는 null-coalesce 연산자가 빈 문자열을 감지하지 못한다는 것입니다.

즉

string result1 = string.empty ?? "dead code!";

string result2 = null ?? "coalesced!";

산출:

result1 = ""

result2 = coalesced!

나는 현재 재정의를 찾고 있습니까? 이 문제를 해결하려면 연산자를 사용하십시오. 이것을 프레임 워크에 내장하는 것이 편리 할 것입니다.

생각?

?? 필요하거나 삼항 연산자를 사용해야합니까 (대부분 익숙한)

자신의 의도를 가장 잘 나타내는 것을 사용해야합니다. 이 때문에 인 널 병합 연산자가 사용 .

반면에, 그것은 매우 전문적이기 때문에 다른 용도가 있다고 생각하지 않습니다. ||다른 언어와 마찬가지로 연산자 의 적절한 과부하를 선호했을 것입니다. 이것은 언어 디자인에서 더 포용 적입니다. 그러나 잘…

멋있는! 널 병합 연산자에 대해 알지 못하는 사람으로 나를 계산하십시오. 그것은 꽤 멋진 일입니다.

삼항 연산자보다 읽기가 훨씬 쉽습니다.

내가 사용할 수있는 첫 번째 장소는 모든 기본 매개 변수를 한곳에 유지하는 것입니다.

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