ฉันจะให้การสนับสนุนนักแสดงที่กำหนดเองสำหรับชั้นเรียนของฉันได้อย่างไร

ฉันจะให้การสนับสนุนในการคัดเลือกชั้นเรียนของฉันเป็นประเภทอื่นได้อย่างไร ตัวอย่างเช่นถ้าฉันมีการใช้การจัดการ a ของตัวเองbyte[]และฉันต้องการให้คนอื่นส่งชั้นเรียนของฉันไปที่ a byte[]ซึ่งจะคืนสมาชิกส่วนตัวฉันจะทำอย่างไร

เป็นเรื่องปกติหรือไม่ที่จะปล่อยให้พวกเขาร่ายสิ่งนี้เป็นสตริงหรือฉันควรจะลบล้างToString()(หรือทั้งสองอย่าง)

คุณจะต้องแทนที่ตัวดำเนินการแปลงโดยใช้อย่างใดอย่างหนึ่งimplicitหรือexplicitขึ้นอยู่กับว่าคุณต้องการให้ผู้ใช้แคสต์หรือต้องการให้เกิดขึ้นโดยอัตโนมัติ โดยทั่วไปทิศทางเดียวมักจะทำงานที่ที่คุณใช้implicitและทิศทางอื่น ๆ explicitบางครั้งอาจล้มเหลวที่ที่คุณใช้

ไวยากรณ์เป็นดังนี้:

public static implicit operator dbInt64(Byte x)
{
    return new dbInt64(x);
}

หรือ

public static explicit operator Int64(dbInt64 x)
{
    if (!x.defined)
        throw new DataValueNullException();
    return x.iVal;
}

สำหรับตัวอย่างของคุณให้พูดจาก Type ที่กำหนดเอง ( MyType-> byte[]จะใช้ได้เสมอ):

public static implicit operator byte[] (MyType x)
{
    byte[] ba = // put code here to convert x into a byte[]
    return ba;
}

หรือ

public static explicit operator MyType(byte[] x)
{
    if (!CanConvert)
        throw new DataValueNullException();

    // Factory to convert byte[] x into MyType
    MyType mt = MyType.Factory(x);
    return mt;
}

คุณสามารถประกาศตัวดำเนินการแปลงในชั้นเรียนของคุณได้โดยใช้คำหลักexplicitหรือimplicit

ตามกฎทั่วไปคุณควรระบุimplicitตัวดำเนินการแปลงเมื่อการแปลงไม่สามารถล้มเหลวได้ ใช้explicitตัวดำเนินการแปลงเมื่อการแปลงอาจล้มเหลว

public class MyClass
{
    private byte[] _bytes;

    // change explicit to implicit depending on what you need
    public static explicit operator MyClass(byte[] b)
    {
        MyClass m = new MyClass();
        m._bytes = b;
        return m;
    }

    // change explicit to implicit depending on what you need
    public static explicit operator byte[](MyClass m)
    {
        return m._bytes;
    }
}

การใช้explicitวิธีการที่ผู้ใช้ในชั้นเรียนของคุณจะต้องทำการแปลงอย่างชัดเจน:

byte[] foo = new byte[] { 1, 2, 3, 4, 5 };
// explicitly convert foo into an instance of MyClass...
MyClass bar = (MyClass)foo;
// explicitly convert bar into a new byte[] array...
byte[] baz = (byte[])bar;

การใช้implicitวิธีการที่ผู้ใช้ในชั้นเรียนของคุณไม่จำเป็นต้องทำการแปลงอย่างชัดเจนทุกอย่างเกิดขึ้นอย่างโปร่งใส:

byte[] foo = new byte[] { 1, 2, 3, 4, 5 };
// imlpicitly convert foo into an instance of MyClass...
MyClass bar = foo;
// implicitly convert bar into a new byte[] array...
byte[] baz = bar;

ฉันชอบที่จะมีวิธีการบางอย่างที่จะทำเช่นนั้นมากกว่าที่จะให้ตัวดำเนินการแคสมากเกินไป

ดูc # อย่างชัดเจนและโดยนัยแต่โปรดทราบว่าจากตัวอย่างนั้นโดยใช้วิธีการที่ชัดเจนหากคุณทำ:

string name = "Test";
Role role = (Role) name;

แล้วทุกอย่างก็เรียบร้อย อย่างไรก็ตามหากคุณใช้:

object name = "Test";
Role role = (Role) name;

ตอนนี้คุณจะได้รับ InvalidCastException เนื่องจากไม่สามารถแคสต์สตริงเป็น Role ได้เพราะเหตุใดคอมไพเลอร์จึงมองหาเฉพาะการร่ายโดยนัย / อย่างชัดเจนในเวลาคอมไพล์ตามประเภทที่คอมไพล์ ในกรณีนี้คอมไพเลอร์มองว่าชื่อเป็นวัตถุแทนที่จะเป็นสตริงดังนั้นจึงไม่ใช้ตัวดำเนินการที่โอเวอร์โหลดของบทบาท

สำหรับการสนับสนุนนักแสดงที่กำหนดเองคุณต้องให้ตัวดำเนินการแคสต์ (โดยชัดแจ้งหรือโดยปริยาย) ตัวอย่างต่อไปนี้ของคลาส EncodedString คือการนำสตริงไปใช้อย่างง่ายด้วยการเข้ารหัสแบบกำหนดเอง (อาจมีประโยชน์หากคุณต้องประมวลผลสตริงขนาดใหญ่และพบปัญหาการใช้หน่วยความจำเนื่องจากสตริง. Net เป็น Unicode - ทุกอักขระใช้หน่วยความจำ 2 ไบต์ - และ EncodedString สามารถใช้ 1 ไบต์ต่อถ่าน)

EncodedString สามารถแปลงเป็นไบต์ [] และเป็น System.String ความคิดเห็นในโค้ดทำให้เกิดความกระจ่างและยังอธิบายตัวอย่างเมื่อการแปลงโดยนัยอาจเป็นอันตรายได้

โดยปกติคุณต้องมีเหตุผลที่ดีมากในการประกาศตัวดำเนินการแปลงใด ๆ ตั้งแต่แรกเนื่องจาก

อ่านเพิ่มเติมที่มีอยู่ในMSDN

class Program
{
    class EncodedString
    {
        readonly byte[] _data;
        public readonly Encoding Encoding;

        public EncodedString(byte[] data, Encoding encoding)
        {
            _data = data;
            Encoding = encoding;
        }

        public static EncodedString FromString(string str, Encoding encoding)
        {
            return new EncodedString(encoding.GetBytes(str), encoding);
        }

        // Will make assumption about encoding - should be marked as explicit (in fact, I wouldn't recommend having this conversion at all!)
        public static explicit operator EncodedString(byte[] data)
        {
            return new EncodedString(data, Encoding.Default);
        }

        // Enough information for conversion - can make it implicit
        public static implicit operator byte[](EncodedString obj)
        {
            return obj._data;
        }

        // Strings in .Net are unicode so we make no assumptions here - implicit
        public static implicit operator EncodedString(string text)
        {
            var encoding = Encoding.Unicode;
            return new EncodedString(encoding.GetBytes(text), encoding);
        }

        // We have all the information for conversion here - implicit is OK
        public static implicit operator string(EncodedString obj)
        {
            return obj.Encoding.GetString(obj._data);
        }
    }

    static void Print(EncodedString format, params object[] args)
    {
        // Implicit conversion EncodedString --> string
        Console.WriteLine(format, args);
    }

    static void Main(string[] args)
    {
        // Text containing russian letters - needs care with Encoding!
        var text = "Привет, {0}!";

        // Implicit conversion string --> EncodedString
        Print(text, "world");

        // Create EncodedString from System.String but use UTF8 which takes 1 byte per char for simple English text
        var encodedStr = EncodedString.FromString(text, Encoding.UTF8);
        var fileName = Path.GetTempFileName();

        // Implicit conversion EncodedString --> byte[]
        File.WriteAllBytes(fileName, encodedStr);

        // Explicit conversion byte[] --> EncodedString
        // Prints *wrong* text because default encoding in conversion does not match actual encoding of the string
        // That's the reason I don't recommend to have this conversion!
        Print((EncodedString)File.ReadAllBytes(fileName), "StackOverflow.com");

        // Not a conversion at all. EncodingString is instantiated explicitly
        // Prints *correct* text because encoding is specified explicitly
        Print(new EncodedString(File.ReadAllBytes(fileName), Encoding.UTF8), "StackOverflow.com");

        Console.WriteLine("Press ENTER to finish");
        Console.ReadLine();
    }
}