C#

string siteCode = "U+1F914";
int i = Convert.ToInt32(siteCode.Replace("U+", "0x"), 16);

<pre lang="c#">txtresults.Text = txttext.Text.Replace("U+", "0x").ToLower();</pre>

Failwyn wrote:

Ultimately, I don't want there to be anything different between the classes other than the ability to use a simplified signature.

MyClass<Guid> a = new MyClass<Guid>();
MyClass<Guid, Guid, Guid, Guid> b = a; // Works
MyClass<Guid> c = b; // Won't compile - needs an explicit cast

MyClass<Guid, Guid, Guid, Guid> a = new MyClass<Guid, Guid, Guid, Guid>();
MyClass<Guid> b = (MyClass<Guid>)a; // Compiles, but fails at runtime
MyClass<Guid> c = a as MyClass<Guid>; // Compiles and runs, but result is null

using MyClassGuid = MyClass<Guid, Guid, Guid, Guid>;
...
MyClassGuid a = new MyClassGuid();

public static class MyClass
{
    public static MyClass<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4)
    {
        return new MyClass<T1, T2, T3, T4>(value1, value2, value3, value4);
    }
    
    public static MyClass<T1, T1, T1, T1> Create<T1>(T1 value)
    {
        return new MyClass<T1, T1, T1, T1>(value, value, value, value);
    }
}
...
MyClass<Guid, Guid, Guid, Guid> a = MyClass.Create(Guid.New());
MyClass<string, int, decimal, DateTime> b = MyClass.Create("Hello", 42, 123.45M, DateTime.Today);

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(MyClass.Create(Guid.NewGuid()).GetType());
        Console.WriteLine(MyClass.Create("Hello", 42, 123.45M, DateTime.Today).GetType());
    }
}

public class MyClass<T1, T2, T3, T4> 
{
    public MyClass(T1 value1, T2 value2, T3 value3, T4 value4) { }
}

public static class MyClass
{
    public static MyClass<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4)
    {
        return new MyClass<T1, T2, T3, T4>(value1, value2, value3, value4);
    }
    
    public static MyClass<T1, T1, T1, T1> Create<T1>(T1 value)
    {
        return new MyClass<T1, T1, T1, T1>(value, value, value, value);
    }
}

MyClass`4[System.Guid,System.Guid,System.Guid,System.Guid]
MyClass`4[System.String,System.Int32,System.Decimal,System.DateTime]

public class MyClass<T1, T2, T3, T4>
{
    public MyClass(T1 value1, T2 value2, T3 value3, T4 value4) { }
}

Quote:

imho, all of these implementations are hacks, and writing straightforward individual methods for each group of Types is better practice.

To me the attempt here to make these generic methods more "generalized" just leads to semantic confusion. It's not that much work to write a bunch of specific methods that can provide strict control over parameter validation, and can be unit tested efficiently.

BillWoodruff wrote:

This perceptual glitch of mine was simply the whine of a small dis-oriented horse-fly orbiting the radiance of your intellect

BillWoodruff wrote:

What interests me, much more, is whether you would agree that the attempt to "bend" the Generic canon here into a variable polymorphism ... is ... a complexity that costs more than its worth in terms of SOLID and future maintenance.

public class MyClass<T1, T2, T3, T4>
{
    public T1 Value1 { get; }
    public T2 Value2 { get; }
    public T3 Value3 { get; }
    public T4 Value4 { get; }

    public MyClass(T1 value1, T2 value2, T3 value3, T4 value4)
    {
        Value1 = value1;
        Value2 = value2;
        Value3 = value3;
        Value4 = value4;
    }
}

public class MyClass<T1> : MyClass<T1, T1, T1, T1>
{
    public MyClass(params T1[] values) : base(values[0], values[1], values[2], values[3])
    {
    }
}

Gerry Schmitz wrote:

One knows how many parameters are passed based the count

public class MyClass<T1, T2, T3, T4>
{
    public T1 Value1 { get; set; }
    public T2 Value2 { get; set; }
    public T3 Value3 { get; set; }
    public T4 Value4 { get; set; }

    public MyClass(T1 value1, T2 value2, T3 value3, T4 value4)
    {
        Value1 = value1;
        Value2 = value2;
        Value3 = value3;
        Value4 = value4;
    }

    protected MyClass()
    {
    }
}

public class MyClass<T1> : MyClass<T1, T1, T1, T1>
{
    public MyClass(params T1[] values)
    {
        if(values.Length != 4) throw new ArgumentException("requires 4 parameters");

        Value1 = values[0];
        Value2 = values[1];
        Value3 = values[2];
        Value4 = values[3];
    }
}

Gerry Schmitz wrote:

Reflection can tell you what's being passed even when using all "objects".

imho, all of these implementations are hacks, and writing straightforward individual methods for each group of Types is better practice. 

To me the attempt here to make these generic methods more "generalized" just leads to semantic confusion. It's not that much work to write a bunch of specific methods that can provide strict control over parameter validation, and can be unit tested efficiently.