How it works
Two interfaces can contain members with the same name but different domain meanings. IBytes.Count measures bytes, while IItems.Count measures logical items. Meter implements both contracts explicitly so the name Count does not silently choose one unit whenever someone reads the concrete object.
Casting meter to IBytes exposes the byte contract and prints one thousand twenty-four. Viewing the same object through IItems prints four. These are two interface views of one instance, not two copies. The explicit member declarations name the interface whose requirement each implementation satisfies.
The concrete Meter type does not expose a public Count property in this example. A caller must choose the interface and therefore the meaning. That can be useful when integrating existing contracts, although a fresh public API might be clearer with names such as ByteCount and ItemCount instead of relying on casts.
Explicit implementation is not a security boundary. Code that has access to the interface type can still cast an instance and use that contract. Its purpose is controlling the API surface and resolving member meanings, not hiding sensitive data or preventing an authorized caller from reaching the functionality.
Practice by adding an IReset interface and implementing its Reset method explicitly. Give Meter private fields for the two counts, print both through their interfaces, reset the object through IReset, and print them again. Make sure the reset operation's effect on both units is documented.
When several interfaces evolve, avoid solving every naming conflict through increasingly complicated explicit members. Ask whether the object truly represents all of those responsibilities. A small adapter can often translate one existing contract to another while keeping the main domain object understandable. Use explicit implementations when the relationship is intentional and test each interface independently.
A working example
using System;
using System.Linq;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;
using System.Runtime.CompilerServices;
var meter = new Meter();
Console.WriteLine(((IBytes)meter).Count);
Console.WriteLine(((IItems)meter).Count);
interface IBytes { int Count { get; } }
interface IItems { int Count { get; } }
class Meter : IBytes, IItems {
int IBytes.Count => 1024;
int IItems.Count => 4;
}
Expected output
1024 4
Access each explicit member through the interface that defines its meaning.