C#

private string StringToNumberString (string inputString) {
    StringBuilder OutputBuilder = new StringBuilder("");

    byte[] ByteArrary = Encoding.ASCII.GetBytes(inputString);

    foreach (byte SingleByte in ByteArrary) {

        // Get the numeric value of this byte
        int ByteValue = Convert.ToInt32(SingleByte);

        // Convert this byte into 3 character string
        // "Right(3)" is an extension method that will return rightmost (x) characters
        string ByteValueString = ("000" + ByteValue.ToString()).Right(3);

        // Add this characters numeric string 
        OutputBuilder.Append(ByteValueString);
    }

    return OutputBuilder.ToString();
}

MadMyche wrote:

// Get the numeric value of this byte
int ByteValue = Convert.ToInt32(SingleByte);

// Convert this byte into 3 character string
// "Right(3)" is an extension method that will return rightmost (x) characters
string ByteValueString = ("000" + ByteValue.ToString()).Right(3);

// Add this characters numeric string 
OutputBuilder.Append(ByteValueString);

• No need to convert to an Int32 - a Byte is already numeric;
• No need for custom padding or extensions methods, when the built-in format strings will do the work for you;

string ByteValueString = SingleByte.ToString("D3");
OutputBuilder.Append(ByteValueString);

// requires your project has a reference to System.Numerics, and a using statement foe it

Guid g = Guid.NewGuid();
byte[] b = g.ToByteArray();
BigInteger bigI = new BigInteger(b);

string s0 = g.ToString();
string s1 = System.Text.Encoding.Unicode.GetString(b);
string s2 = System.Text.Encoding.UTF8.GetString(b);
string s3 = System.Text.Encoding.ASCII.GetString(b);
string s4 = bigI.ToString();

Console.WriteLine($"guid to string: {s0}\r\nbyte[] to Unicode string: {s1}\r\nbyte[] to UTF8 string: {s2}\r\nbyte[] to ASCII string: {s3}\r\nbyte[] to BigInt to string: {s4}");

static ArithmeticObject AdditiveIdentity(Type type)
{
    if (type.Equals(typeof(Number)))
        return Zero;
    return new Polynomial(new List<Integer>());
}
static ArithmeticObject MultiplicativeIdentity(Type type)
{
    if (type.Equals(typeof(Number)))
        return One;
    return new Polynomial(new List<Integer> { One });
}

protected abstract ArithmeticObject Multiply(ArithmeticObject a);

T Multiply<T>(T a);

public bool IsNumber {get {return (this is Number);} }
public bool IsPolynomial {get {return (this is Polynomial);} }

using System.Collections.Generic;
using System.Linq;

namespace YourNameSpace
{
    public interface IArithmetic<T>
    {
        T TValue { set; get; }
    }

    public interface INumber : IArithmetic<int>
    {
    }

    public interface IPolynomial : IArithmetic<List<int>>
    {
    }

    public interface IOperators<T>
    {
        T TAdd(T t1, T t2);
    }

    public class Number : INumber, IOperators<Number>
    {
        public Number(int value = 0)
        {
            TValue = value;
        }

        public int TValue { get; set; }

        public static Number operator +(Number n1, Number n2)
        {
            Number newNumber = new Number();
            newNumber.TValue = n1.TValue + n2.TValue;
            return newNumber;
        }

        public Number TAdd(Number t1, Number t2)
        {
            return t1 + t2;
        }
    }

    public class Polynomial : IPolynomial, IOperators<Polynomial>
    {
        public Polynomial(params int[] ints)
        {
            TValue = ints.ToList();
        }

        public List<int> TValue { get; set; }

        // concatenation here
        public static Polynomial operator +(Polynomial p1, Polynomial p2)
        {
            Polynomial newPolynomial = new Polynomial();
            newPolynomial.TValue = p1.TValue.Concat(p2.TValue).ToList();
            return newPolynomial;
        }

        public Polynomial TAdd(Polynomial t1, Polynomial t2)
        {
            return t1 + t2;
        }
    }

    public static class ArithmeticExtensions
    {
        public static Number Add(this Number n1, Number n2)
        {
            Number n = new Number();

            n.TValue += n1.TValue + n2.TValue;

            return n;
        }

        public static Number Add(this Number n1, Polynomial p1)
        {
            Number n = new Number(n1.TValue);

            foreach (int i in p1.TValue)
            {
                n.TValue += i;
            }

            return n;
        }

        // addition performed here
        public static Polynomial Add(this Polynomial p1, Polynomial p2)
        {
            Polynomial p;

            if (p1.TValue.Count == p2.TValue.Count)
            {
                p = new Polynomial(p1.TValue.ToArray());

                for (int i = 0; i < p.TValue.Count; i++)
                {
                    p.TValue[i] += p2.TValue[i];
                }
            } else if (p1.TValue.Count < p2.TValue.Count)
            {
                // p1 has fewer values
                p = new Polynomial(p2.TValue.ToArray());

                for (int i = 0; i < p1.TValue.Count; i++)
                {
                    p.TValue[i] += p1.TValue[i];
                }
            }
            else
            {
                // p1  has more values
                p = new Polynomial(p1.TValue.ToArray());

                for (int i = 0; i < p2.TValue.Count; i++)
                {
                    p.TValue[i] += p2.TValue[i];
                }
            }

            return p;
        }

        public static Polynomial Add(this Polynomial p1, Number n1)
        {
            Polynomial p = new Polynomial(p1.TValue.ToArray());

            for (int i = 0; i < p.TValue.Count; i++)
            {
                p.TValue[i] += n1.TValue;
            }

            return p;
        }
    }
}

public void Teat()
{
    Number n1, n2;
    Polynomial p1, p2;
    
    n1 = new Number(100);
    n2 = new Number(200);
    p1 = new Polynomial(1,2,3, 4, 5, 6);
    p2 = new Polynomial(7,8,9);
    
    var n3 = n1 + n2;  // use of operator overloading
    var p3 = p1 + p2;  // => {1,2,3,4,5,6,7,8,9}
    
    var p4 = p1.Add(p2); // use of Extension Methods
    var p5 = p2.Add(p1); // both => {8,10,12,4,5,6}
    
    var p6 = p1.Add(n1); // add Number to Polynomial => {101 ~ 106}
    var n4 = n2.Add(p2); // add Polynomial to Number => 224
}