班级名称 <Type> 或ClassName <Object> 用于抽象基类

Question

I'm relatively newbie to C# programming. I want to create Abstract Base Class that contains a few of abstract , and virtual methods.

By the following two examples, what are their differences of usage and which is more commonly used?

Example-1, use Type keyword.

public abstract class DecoratorBase<Type> : ValidatableBindableBase
{
    public virtual void SetFields(Type T) { }
    public virtual void SetFieldsBack(ref Type T) { }
}

Example-2, use Object keyword.

public abstract class DecoratorBase<Object> : ValidatableBindableBase
{
    public virtual void SetFields(Object T) { }
    public virtual void SetFieldsBack(ref Object T) { }
}

In my case, Type or Object will represent my business model POCO class.

Sorry, if this question sound so naive to you. Thanks.

Answer 1

Please, don't do that!

It looks like you're a little confused about generics. When you define a generic abstract type (using < and > after the name), you're telling the compiler "I will give you some type, but I don't know which type just now. Use the name I'm giving you as a placeholder for the type later." The convention is to use the upper case T .

For example, the following defines a generic abstract class.

public abstract class SomeClass<T> {}

Later, when we create a derived class, we create it with a type:

public class ConcreteClass : SomeClass<int> {}

If we had methods declared in our abstract class that used the type T , our new ConcreteClass would replace references to T with int . So in your case, you should do:

public abstract class DecoratorBase<T> : ValidatableBindableBase
{
    public virtual void SetFields(T param) { }
    public virtual void SetFieldsBack(ref T param) { }
}

You can see here, T represents the unknown type as T , instead of naming the type Type and the parameter T . What you were doing is known as 'hiding', that is, When you use Type or Object in the way you were doing, it is assigning a new meaning to those words. You should absolutely avoid hiding in this way.

Now if you create a concrete class, say:

public class Decorator : DecoratorBase<Control>
{
    public override SetFields(Control param) {}
}

You have type safety: the parameter now has to be a Control , at least for this concrete implementation. You can define other implementations with different types, and inherit the same base methods.

See this question for a simple understanding of how to use generics.