public byte Some
{
   get { return this.Some; }
   set { this.Some = value; }
}

These calls are recursive - and you haven't declared any actual
storage.

Remember that the properties are just method calls in disguise. As soon
as I rewrite the properties this way, I'm sure you'll see why it
doesn't work:

public byte GetSome()
{
   return GetSome();
}

public void SetSome(byte value)
{
   SetSome(value);
}

You probably *meant* it to be something like this:

// Field backing the property
private byte some;
// Property
public byte Some
{
   // Note case changes
   get { return this.some; }
   set { this.some = value; }
}

Just from the code you posted, it seems like you are also stuck on the  
"get".  That code has unterminated recursion in both the setter and getter  
and will crash with a stack overflow exception using either.

No offense, but I vote for "slow".  :)  Or at least (and maybe more  
polite), ill-informed.

The reason the automatic property works is that using that syntax the  
compiler generates the needed member field to store the value for you.  In  
the code you wrote, you don't provide anywhere to store the value.  Even  
worse, you get the property by retrieving the property, and you set the  
property by assigning the property.  Both of those implementations just  
wind up calling the property again over and over until you run out of  
stack.

If you're going to write your own property, you need to provide a place to  
put the data.  The getter and setters need to use this place, rather than  
calling themselves over and over.  A correct implementation might look  
something like this:

    private byte _some;

    public byte Some
    {
        get { return _some; }
        set { _some = value; }
    }

And in fact, this is essentially what the automatic declaration for a  
property does for you.  If this is all you're doing, stick with the  
automatic declaration.  You only need to write it explicitly if you need  
some extra functionality, such as being able to access the backing field  
without going through the property, raising an event when the property  
changes, etc.

If this doesn't clear things up, you might want to actually read the  
documentation on MSDN regarding properties in C#:
http://msdn2.microsoft.com/en-us/library/x9fsa0sw.aspx

Pete