实现抽象类与接口

Question

我是使用接口和抽象类的新手。与我一起工作的团队提出了一个他们称之为基类的实现，它将由所有视图模型类实现。这就是他们想出的办法:

public interface IBaseViewModel<T>
{
#region public properties
string Message { get; set; }
string SaveType { get; set; }
bool IsVisibleMessage { get; set; }
bool IsVisibleDecision { get; set; }
bool IsApiSuccess { get; set; }
Guid EntityId { get; set; }
string EntityQDSId { get; set; }
string EntityType { get; set; }
#endregion
#region public methods
Task Init();
Task Init(Guid Id);
Task<T> Create();
Task<T> Get(Guid Id);
Task<T> Get(string Id);
Task<IEnumerable<T>> GetList(Guid Id);
Task<IEnumerable<T>> GetList(string Id);
Task<T> Insert(T t);
Task<T> Update(Guid Id, T t);
Task<T> Delete(Guid Id);
void Dispose();
#endregion
}
public abstract class BaseViewModel<T> : IBaseViewModel<T>, IDisposable
{
public Guid EntityId { get; set; }
public string EntityQDSId { get; set; }
public string EntityType { get; set; }
public string Message { get; set; }
public string SaveType { get; set; }
public bool IsVisibleMessage { get; set; }
public bool IsVisibleDecision { get; set; }
public bool IsApiSuccess { get; set; }
public virtual Task Init()
{
return Task.FromResult<T>(default);
}
public virtual Task Init(Guid Id)
{
return Task.FromResult<T>(default);
}
public virtual Task<T> Create()
{
return Task.FromResult<T>(default);
}
public virtual Task<T> Get(Guid Id)
{
return Task.FromResult<T>(default);
}
public virtual Task<T> Get(string Id)
{
return Task.FromResult<T>(default);
}
public virtual Task<IEnumerable<T>> GetList(Guid Id)
{
return Task.FromResult<IEnumerable<T>>(default);
}
public virtual Task<IEnumerable<T>> GetList(string Id)
{
return Task.FromResult<IEnumerable<T>>(default);
}
public virtual Task<IEnumerable<T>> GetForGrid(Guid Id)
{
return Task.FromResult<IEnumerable<T>>(default);
}
public virtual Task<T> Insert(T t)
{
return Task.FromResult<T>(default);
}
public virtual Task<T> Update(Guid Id, T t)
{
return Task.FromResult<T>(default);
}
public virtual Task<T> Delete(Guid Id)
{
return Task.FromResult<T>(default);
}
public virtual void ProcessDto(T t)
{
}
public virtual void Dispose()
{
}
}

实现如下:

public interface IAccountBillViewModel<T> : IBaseViewModel<AccountBillGroup>
{
}
public class AccountBillViewModel<T> : BaseViewModel<AccountBillGroup>, IAccountBillViewModel<AccountBillGroup>
{
}

在研究这个问题时，我发现了一些像下面这样的评论

https://stackoverflow.com/a/479154[@Alex] [1]

我的点:

1. 既然在抽象类中只有代码签名而没有任何代码的实现，并且因为你可以从多个接口继承，为什么要使用抽象类而不是接口呢?
2. 继承槽将保持开放，以防将来我们想从其他类继承。
点

:

1. 这些属性只需要在基类中实现，并且这些属性将在所有实现中可用，而无需再次声明属性。
2. 只有那些需要在实现中使用的方法需要被重写。如果使用一个接口，所有的方法都必须在每个实现中实现。

当没有实现，只有方法签名时，选择抽象基类有价值吗?

Answer 1

我更喜欢使用接口，因为类可以实现多个接口。

当你拥有一些可以在继承类时重用的默认行为时，抽象类更有意义。