C# difference between a cast and using "as" operator

In C#, the primary difference between a cast (T)obj and the as operator is how they handle failed conversions: a cast throws an exception, while the as operator returns null. 

Key Differences

Feature	Direct Cast (T)obj	as Operator obj as T
Failure Result	Throws InvalidCastException	Returns null
Type Support	Works with any type (Reference & Value)	Works only with Reference or Nullable types
User Conversions	Executes User-defined conversions	Ignores user-defined conversions
Performance	Can be slower if it fails (exception overhead)	Generally faster for testing types safely

When to Use Each

• Use a Direct Cast (T)obj when you are certain the object is of the target type. If it fails, it indicates a bug, and throwing an exception immediately is safer than propagating bad data.
• Use the as Operator when you are not sure of the type and want to branch your logic based on the result. This requires a null-check immediately following the operation.
• Modern Alternative: In newer versions of C#, you can use the is operator with pattern matching to check and cast in a single step:
  csharp

  if (obj is MyType myTypedObj) 
  {
      // Use myTypedObj here
  }

Key Differences at a Glance

Feature	Cast Expression (Type)obj	as Operator obj as Type
Failure Result	Throws InvalidCastException	Returns null
Supported Types	All compatible types (reference & value)	Reference types or nullable value types only
Custom Conversions	Invokes user-defined conversion operators	Ignored; only reference, boxing/unboxing conversions
Best Intent	"I expect this to be this type; error if not."	"I'm not sure; let me check and handle it."

Modern Pattern Matching: "is"

In older C#, you often had to perform two steps: check the type with is and then cast it. Today, you can do this in one line: 

csharp

// The Modern Way: Pattern Matching (C# 7.0+)
if (obj is MyType myVar) 
{
    // myVar is already cast and ready to use here
    Console.WriteLine(myVar.SomeProperty);
}

Key Advantages over "as" and Casts

• Safety & Cleanliness: It combines the check and the cast into a single expression, reducing code bloat and the risk of a NullReferenceException that can happen if you forget a null check after using as.
• Better than "as" for Value Types: The as operator only works with reference or nullable types. Pattern matching works seamlessly with both value types (like int) and reference types (like string).
• Expressiveness: Modern is supports complex patterns like logical patterns (not, and, or) and property patterns (checking internal object properties).
  csharp

  // C# 9.0+ logical patterns
  if (input is not null) { ... }
  
  // Complex matching
  if (shape is Rectangle { Width: > 10 } r) { ... }
  

  
  
• Avoids Double Checking: Unlike the old if (obj is MyType) { var x = (MyType)obj; }, pattern matching only performs the runtime type check once, making it more efficient. 

Recommendations

• For null checks: Use if (obj is null) or if (obj is not null). This is safer than == null because it ignores any operator overloading that might change the result.
• For general type-casting: Prefer is pattern matching over as whenever you need to use the variable immediately after the check.