Converting Object to Byte Array and String in C#

By the end of this page, you will understand why Encoding.UTF8.GetString(...) expects a byte[], why searchResult.Properties["user"][0] is seen as an object, and how to correctly cast or convert values in C#. You will also learn when you should use encoding at all, and when a simple cast to string is the correct solution.

In C#, many APIs return values as object when the exact type is not known at compile time. That is what is happening with:

searchResult.Properties["user"][0]

Even if the real value stored there is a string or a byte array, the compiler only sees object. Because of that, you cannot pass it directly into:

Encoding.UTF8.GetString(...)

That method expects raw bytes:

byte[]

Why this matters

This is a very common issue in C#:

• APIs return object
• you must determine the real runtime type
• then you cast or convert appropriately

If the property already contains a string, you should not decode it with Encoding.UTF8.GetString. It is already decoded.

If the property contains binary data, then you must first cast it to byte[].

Important rule

Use Encoding.UTF8.GetString(...) only when you have bytes that represent text.

Use a cast like (string)value or when the value is already text.

Think of object as a sealed package with no label.

The compiler sees only the package, not what is inside.

• Encoding.UTF8.GetString(...) says: "I only accept a package that contains bytes."
• Your code is handing it a generic package labeled only as object.

So you must first open the package conceptually by checking or casting its real type:

• if it contains byte[], decode it
• if it contains string, use it directly

A cast in C# is like telling the compiler: "I know what is really inside this package."

Core syntax

If the value is already a string

object value = searchResult.Properties["user"][0];
string user = (string)value;

If the value is a byte array

object value = searchResult.Properties["user"][0];
string user = Encoding.UTF8.GetString((byte[])value);

Safer type checking with pattern matching

object value = searchResult.Properties["user"][0];

if (value is string text)
{
    profile.User = text;
}
else if (value is byte[] bytes)
{
    profile.User = Encoding.UTF8.GetString(bytes);
}

This is beginner-friendly and safe because it handles both common cases.

Example 1: value is already a string

Consider this example:

object value = Encoding.UTF8.GetBytes("bob");

if (value is byte[] bytes)
{
    string user = Encoding.UTF8.GetString(bytes);
    Console.WriteLine(user);
}

Step by step

1. Encoding.UTF8.GetBytes("bob") creates a byte[] containing the UTF-8 bytes for the text bob.
2. That byte array is stored in a variable of type object.
3. The if (value is byte[] bytes) check asks: "Is the real runtime type a byte array?"
4. Since it is, C# creates a typed variable named bytes.
5. Encoding.UTF8.GetString(bytes) decodes those bytes back into a string.
6. Console.WriteLine(user) prints:

bob

Compare with the failing version

object value = Encoding.UTF8.GetBytes();
 user = Encoding.UTF8.GetString(); 

This pattern appears often in real C# programs.

1. Reading directory service properties

Search results from LDAP or Active Directory often expose attribute values as generic objects. You may need to cast them to:

• string
• byte[]
• numeric types
• DateTime

2. Working with files or network data

When reading raw data from a file, socket, or API, text usually arrives as bytes:

byte[] data = File.ReadAllBytes("user.txt");
string text = Encoding.UTF8.GetString(data);

3. Parsing values from loosely typed APIs

Older libraries, reflection-based systems, and configuration providers often return object. You must inspect the real type before using it.

4. Database and serialization code

Some database fields may store binary data, and some systems serialize strings into bytes for transmission or storage.

In real projects, developers usually do not assume a loosely typed value has the correct type. They add checks and fail safely.

Common patterns

Guard clause

if (searchResult.Properties["user"].Count == 0)
{
    return;
}

This exits early if the property does not exist.

Type-safe extraction

object value = searchResult.Properties["user"][0];

if (value is string text)
{
    profile.User = text;
    return;
}

if (value is byte[] bytes)
{
    profile.User = Encoding.UTF8.GetString(bytes);
    return;
}

Fallback handling

object value = searchResult.Properties["user"][0];
profile.User = value?.ToString();

This can work for display purposes, but it is not always appropriate for binary data because byte[].ToString() does produce the text contents.

1. Passing object directly into GetString

Broken code:

object value = searchResult.Properties["user"][0];
string user = Encoding.UTF8.GetString(value);

Why it fails:

• GetString expects byte[]
• value is declared as object

Fix:

string user = Encoding.UTF8.GetString((byte[])value);

2. Using GetString on normal text

Broken idea:

object value = "alice";
string user = Encoding.UTF8.GetString((byte[])value);

Why it fails:

Casting vs converting

Quick reference

Convert string to bytes

byte[] bytes = Encoding.UTF8.GetBytes("hello");

Convert bytes to string

string text = Encoding.UTF8.GetString(bytes);

Cast object to string

string text = (string)value;

Cast object to byte[] and decode

string text = Encoding.UTF8.GetString((byte[])value);

Safe runtime type check

if (value is string s)
{
    // use s
}
else if (value is byte[] b)
{
    // decode b
}

Rules to remember

• GetString needs

Why does C# say it cannot convert from object to byte[]?

Because the compiler only sees the variable type object. You must cast it or check its real runtime type first.

When should I use Encoding.UTF8.GetString()?

Use it only when you already have a byte[] that represents text encoded in UTF-8.

What if the property value is already a string?

Just cast it to string or assign it directly after a type check.

Can I use ToString() instead?

Only if you want a general string representation. It is not a replacement for decoding bytes. For byte[], ToString() usually returns System.Byte[].

How can I safely handle both strings and byte arrays?

Use pattern matching:

if (value is string s) { ... }
else if (value is [] b) { ... }

• Type casting in C# — Needed when working with values stored as object.
• Boxing and unboxing — Helps explain why generic object values need explicit conversion.
• Strings in C# — Important for understanding when text is already decoded.
• Byte arrays in C# — Useful for file I/O, network data, and binary storage.
• Character encoding — Explains how text is converted to and from bytes.
• Pattern matching in C# — A safe way to check runtime types before using values.
• Null checking — Important when reading values from external sources like directory properties.