标签: base-class

我可能措辞完全错了,但基本上,我有以下基类:

public class ScheduleableService<T> : ServiceBase
        where T : IJob
{
        var x = typeof(T);
}

这个的实现是这样的:

public class MyScheduledService: ScheduleableService<MyScheduledJob>
{
    //MyScheduledJob implements IJob
}

基本上,我需要的是,在我的基类ScheduleableService中,能够获取MyScheduledService类型 - 有没有办法我可以做到这一点而不传递它.

以下作品,但是很难......

public class ScheduleableService<T, S> : ServiceBase
    where T : IJob
    where S : ServiceBase
{

    var x = typeof(T);
    var y = typeof(S);
}

执行:

public class MyScheduledService: ScheduleableService<MyScheduledJob,
                                                     MyScheduledService>
{
    //MyScheduledJob implements IJob
}

我有一些用户控件,我想指定属性和方法.

它们继承自基类,因为它们都具有诸如"Foo"和"Bar"之类的属性,并且我使用基类的原因是我不必在每个派生类中手动实现所有这些属性.

但是,我希望有一个方法只在派生类中,而不是在基类中,因为基类不知道如何"执行"该方法,所以我想为此使用一个接口.如果我把它放在基类中,我必须定义一些body来返回一个值(这将是无效的),并始终确保重写方法不调用基类.方法

是否正确的方法是使用基类和接口来公开方法？它似乎非常圆润,但我认为这样做的每一种方式似乎都是错误的......

让我知道如果问题不清楚,这可能是一个愚蠢的问题,但我想这样做.

编辑:感谢所有人提供了优秀的抽象建议,但这打破了设计师.如果抽象不是一个可选择的选项,你会怎么做？

在我的解决方案中，有许多类C1，等等C2，C3它们都继承自一个公共抽象基类CB。

还有许多类D1、D2等D3充当相应C类的数据源（例如， 的数据源C1是类型D1等的本地属性）。这些D类都继承自一个公共抽象基类DB，但其实现有所不同（该类使用继承和非继承的属性和方法C）。

现在，我想强加一条规则，即所有C类（即派生自CB）必须实现“数据源”属性，并且该属性的类型必须派生自DB。

我最初的想法是这样做：

public abstract class CB
{
    protected abstract DB DataSource { get; set; } 

    etc.
}

然而，这意味着类DataSource中被重写的属性C只能是类型DB，而不是派生自 的类型DB。

我如何实施我的规则？理想情况下CB， 和DB仍将保留抽象基类（因为每个类中都有非抽象属性和方法，我希望C和D类继承），但如果需要，它们可以转换为接口。但我认为如果我这样做的话我会遇到完全相同的问题。

我有以下代码

#include <iostream>
using namespace std;

class B{
    int i;
    public:
    B(){
        cout << "Constructing B\n";
    }
    void print(){
        cout << "Printing from B with size : "<<sizeof(*this)<<endl;
    }
};



class D:public B{
    int i;
    public:
    D(){
        cout << "Constructing D\n";
    }
    void print(){
        cout << "Printing from D with size : "<<sizeof(*this)<<endl;
    }
};


int main(){

    B b;
    b.print();
    D d;
    d.print();

    D* dp;
    dp->print();
}

这给了我以下输出:

Constructing B
Printing from B with size : 4
Constructing B
Constructing …

C++/CLI有一个System :: Object类来实现这个目的,但我似乎无法在标准库中找到它.基本上我正在编写一组类,我希望基类std::string在content属性中存储向量,但派生类可能需要存储其他东西的向量(甚至可能是我自己的类之一).这似乎是一个奇怪的目标,但我正在写一些文件访问类,让我更容易操作不同格式的文件.基File类将每个行存储在一个字符串中,作为向量的一部分 - 但是,例如,JSON的类可能需要存储JS样式的集合/对象等.

我能想到的唯一方法就是让content属性成为对象的向量(或者其他一些通用的基类 - 我也可以从多态性中派生出任何自定义类),然后将其转换回任何类型的必要类型关于正在使用的子对象的类型.我很快就发现在任何std::object地方都找不到(或类似的).

这个例子应该展示我正在尝试做的事情:

class File {
protected:
    std::vector<std::object> _content;

public:
    //Contructors/methods/etc.

    std::string getItemAt(size_t index) {
        return static_cast<std::string>(this->_content[index]);
    }

    void setItemAt(size_t index, std::string value) {
        this->_content[index] = static_cast<std::object>(value);
    }
};

class JSONFile: File {
public:
    //Constructors/methods/etc.

    SomeObject getItemAt(size_t index) {
        return static_cast<SomeObject>(this->_content[index]);
    }

    void setItemAt(size_t index, SomeObject value) {
        this->_content[index] = static_cast<std::object>(value);
    }
};

请注意,此示例假定std::object存在,并且这SomeObject将是用于处理JSON(例如,再次,例如,这可能是任何东西)数据的任何内容.SomeObject显然会来源于std::object.

任何建议将不胜感激,或者 …

我有两个类，一个叫做 MemberModel，一个叫做 CustomPrincipal。CustomPrincipal 类继承 MemberModel 类。

MemberModel 类如下所示：

namespace example.Models
{
    public class MemberModel
    {
        [Required]
        public string Username { get; set; }
        [Required]
        public string Password { get; set; }

        public bool Remember { get; set; }
    }
}

CustomPrincipal 类如下所示：

namespace example.Examples
{
    public class CustomPrincipal : MemberModel, IPrincipal
    {
        public CustomPrincipal(IIdentity identity)
        {
            this.Identity = identity;
        }

        public IIdentity Identity { get; private set; }

        public bool IsInRole(string role) { return false; }
    }
}

在下面的示例中，您会看到两个类 MemberModel …

所以我上课了:

    class TestCollection : Collection<Person> {

    }

从main我添加两个Person对象.我想知道有没有办法在不传递TestCollection tc的情况下访问TestMethod中的这两个对象？例如

    class TestCollection : Collection<Person> {
        public void TestMethod(TestCollection tc) {

        }
    }

有没有办法在没有基类名称和范围解析运算符的情况下引用基类模板的成员变量？

template<typename D>
struct B0 {
    int value;
};
struct D0: B0<D0> {
    D0() {
        B0<D0>::value = 1; // OK.
        value = 1;         // OK without `B0<D0>::`.
    }
};

template<typename T>
struct B1 {
    T value;
};
template<typename T>
struct D1: B1<T> {
    D1() {
        B1<T>::value = 1; // OK.
        // value = 1; // Compile error without `B1<T>::`.
                      // Compile error: use of undeclared identifier 'value'
                      // `B1<T>::` is tedious everywhere `value` is referenced.
    }
};

template<typename T, typename …

我有一个从特定模板实例派生的非模板类。像往常一样，基类必须在派生类的构造函数中初始化。我发现在调用构造函数时可以省略特定的模板参数：主要编译器（VC、g++、clang）接受它。这看起来很奇怪，因为类模板本身不是类名：

$ cat template-base.cpp && g++ --pedantic -o template-base template-base.cpp  && ./template-base

template <int I>
struct T
{
        T(int) {}
};

struct DT: public T<1>
{
        // Note: T<1>(42) is possible but not necessary.
        // T<2>(42) is an error ("T<2> is not a base class", which is correct).
        DT(): T(42) {}
};

int main()
{
        DT dt;
}

（Johannes Schaub 回答了这个类似的问题，其中派生类本身也是一个模板。在这种情况下，模板参数是强制性的，即使它在那里同样可以推导出。）

为什么我可以在这里使用像类名这样的模板名称？T不是一个班！

我对继承的理解非常基本。

我想创建一个基类，它实现IDisposable然后让其他具有功能的类从该基类继承，以便它们共享一个基类型。

它将允许我将每个对象放入一个列表中，以便我可以在需要清理时一次性处理所有内容。问题是，C# 中的类只能继承一次，否则只能使用接口。

现在，像Thread, 之类的类如何从我的基类继承而无需我重新编写Thread该类的基本代码？

这听起来可能很愚蠢，但简而言之：我想让已经存在的类继承我选择的基类，而不会失去其功能。（这样一个项目中使用的所有类都有一个共同的基础，总结为一种对象类型，例如List）

这甚至可能吗？