C# basic knowledge compilation: C# classes and structures (4)

1. What is an interface? Features? Implement code?
An interface is defined using the interface keyword. It consists of a combination of class members and is a set of specifications that describes some functions. As you can see in C#, some interfaces of the system are named like this: IComparable (type comparison method), ICloneable (supports cloning), IDisposable (releases resources), etc. I represents the interface, and able reflects the characteristics of the interface. : "Can..." indicates what this set of specifications can do.
(1), Interface implementation

   public interface IPrintAble
    {
        void PrintString();

        void PrintInt();

        void PrintBool();
    }

    public interface IComputeAble
    {
        void HandlerString();

        void HandlerInt();

        void HandlerBool();
    }

    public class MyInplementInterface : IPrintAble, IComputeAble
    {
        //隐式实现
        public void PrintString()
        {
            Console.WriteLine(@"1");
        }

        public void PrintInt()
        {
            Console.WriteLine(1);
        }

        public void PrintBool()
        {
            Console.WriteLine(true);
        }

        public void HandlerString()
        {
            Console.WriteLine(@"1" + "1");
        }

        public void HandlerInt()
        {
            Console.WriteLine(1 + 1);
        }

        public void HandlerBool()
        {
            Console.WriteLine(true || false);
        }

        //显示实现
        //void IComputeAble.HandlerString()
        //{
        //    throw new NotImplementedException();
        //}

        //void IComputeAble.HandlerInt()
        //{
        //    throw new NotImplementedException();
        //}

        //void IComputeAble.HandlerBool()
        //{
        //    throw new NotImplementedException();
        //}
    }
      class Program
    {
        static void Main(string[] args)
        {
            MyInplementInterface imple = new MyInplementInterface();

            imple.PrintString();

            imple.PrintInt();

            imple.PrintBool();

            imple.HandlerString();

            imple.HandlerInt();

            imple.HandlerBool();

            Console.ReadLine();
        }
    }

Result:

(2) Implement a special interface, that is, an interface that has been defined by C
#Example:

    public class ImplementSysInterface : IComparable
    {
        public int CompareTo(object obj)
        {
            //可以根据需要实现自己的比较方法
            return 0;
        }

        private void UsingMenthod()
        {
            //报错，因为NoIDisposeableClass没有实现IDisposable接口，所以不支持using
            //using (NoIDisposeableClass my = new NoIDisposeableClass())
            //{

            //}
            //实现IDisposable接口后，可以使用using
            using (IDisposeableClass my = new IDisposeableClass())
            {

            }
        }
    }

    public class NoIDisposeableClass
    {

    }

    public class IDisposeableClass : IDisposable
    {
        #region IDisposable 成员

        public void Dispose()
        {
            
        }

        #endregion
    }

The interface has the following characteristics:
a. The interface is similar to an abstract base class and cannot be instantiated directly; the methods in the interface are all abstract methods, and any non-abstract type that implements the interface must implement all members of the interface:
b. When members of the interface are explicitly implemented, the implemented members cannot be accessed through class instances, but can only be accessed through interface instances.
For example:

   public class MyInplementInterface2 : IComputeAble
    {
        void IComputeAble.HandlerString()
        {
            Console.WriteLine(@"1" + "1");
        }

        void IComputeAble.HandlerInt()
        {
            Console.WriteLine(true || false);
        }

        void IComputeAble.HandlerBool()
        {
            Console.WriteLine(true || false);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IComputeAble imple2 = new MyInplementInterface2();

            imple2.HandlerString();

            Console.ReadLine();
        }
    }

c. When the members of the interface are implicitly implemented, the implemented members can be accessed through class instances or interface instances, but the implemented members must be public.
d. The interface cannot contain constants, fields, operators, instance constructors, destructors or types, and cannot contain static members.
e. Interface members are automatically public and cannot contain any access modifiers.
f. The interface itself can inherit from multiple interfaces, and classes and structures can inherit from multiple interfaces, but interfaces cannot inherit from classes.

2. What are generics? What are the advantages of generics?
The so-called generics introduce the concept of type parameters to .NET, and realize the operation of multiple data types on the same code through parameterized types. It is a reference type and a heap object.
Actually, I first learned about generics when I was learning Java. I didn’t understand it at the time. I always felt that generics were unnecessary and could be done with objects. For example, as follows, for example, someone wants to print out the value of the type, so the object is implemented:

    public class Test
    {
        private object model;

        public object Model
        {
            get
            {
                return model;
            }

            set
            {
                model = value;
            }
        }

        public Test(object model)
        {
            this.Model = model;
        }

        public void ShowRecord()
        {
            Console.WriteLine(model);
        }
    }
   class Program
    {
        static void Main(string[] args)
        {
            int recordI = 2;

            bool recordB = true;

            Test testI = new Test(recordI);

            testI.ShowRecord();

            Test testB = new Test(recordB);

            testB.ShowRecord();

            Console.ReadLine();
        }
    }

But when you learn more, you will find that there are still certain problems. First of all, there is the problem of boxing. Int is a value type. When assigning a value to the object type, a boxing operation must be completed. What is crating? It is to copy the recordI value to the space allocated by the new object. Wasted time and performance. So generics still have a role, then, use generics to implement:

  public class TestGeneric<T>
    {
        private T model;

        public T Model
        {
            get
            {
                return model;
            }

            set
            {
                model = value;
            }
        }

        public TestGeneric(T model)
        {
            this.Model = model;
        }

        public void ShowRecord()
        {
            Console.WriteLine(model);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            int recordI = 2;

            bool recordB = true;

            TestGeneric<int> testGI = new TestGeneric<int>(recordI);

            testGI.ShowRecord();

            TestGeneric<bool> testGB = new TestGeneric<bool>(recordB);

            testGB.ShowRecord();

            Console.ReadLine();
        }
    }

In this way, when TestGenericbd43222e33876353aff11e13a7dc75f6 testGI = new TestGenericbd43222e33876353aff11e13a7dc75f6(recordI), T is int, no need to dress Boxed.
Of course, generics are not just about solving the boxing problem. The functional features are as follows:
a. Avoid boxing and unboxing, which improves performance;
b. Improves code reusability;
c , Type-safe, because it will be detected during compilation;
d. You can create your own generic interfaces, generic classes, generic methods, generic events and generic delegates.
The above is the content of C# basic knowledge: C# classes and structures (4). For more related content, please pay attention to the PHP Chinese website (www.php.cn)!