标签: implementation

在定义结构并继承Interface和/或Abstract Class时,哪一个是最佳实践？为什么？这里有两个例子:

以下是[Interface] - > [Abstract Class] - > [Class]的示例

Interface DataInterface
{
    public function __construct($connection);
    public function connected();
    public function get();
}

Abstract class BaseData implements DataInterface
{
    protected $connection;

    public function __construct($connection)
    {
        $this->connection = $connection;
    }
}


class UserData extends BaseData
{
    public function exists()
    {
        return is_connected($this->connection);
    }

    public function get()
    {
        return get_data($this->connection);
    }
}

$oUserData = new UserData(new Connection());

这里是没有接口的[Abstract Class] - > [Class]的示例

Abstract class BaseData
{
    protected $connection;

    public function __construct($connection)
    { …

我正在使用R语言,R网站上的手册非常有用.但是,我想看一些R的例子和实现,它可以帮助我更快地发展我的知识.有什么建议？

我需要在现有站点中实现主/从/负载平衡.

有没有人使用这些(或其他)实现进行主/从切换？

我找到的关于如何在Cake中实现主/从的资源:

• (首选)gamephase.net/posts/view/master-slave-datasource-behavior-cakephp
• http://bakery.cakephp.org/articles/view/master-slave-support-also-with-multiple-slave-support
• http://bakery.cakephp.org/articles/view/load-balancing-and-mysql-master-and-slaves-2

我大部分时间都在工作,但是在某些连接方面有问题.

我欢迎主/从实现的新来源,黑客或mods,因为现在我无法理解它.

(我使用atm的蛋糕版本是1.2)(我在CakePHP的谷歌小组http://groups.google.co.uk/group/cake-php/browse_thread/thread/4b77af429759e08f上交叉发布)

我一直在尝试用Python实现这个算法几天.我一直回到它,只是放弃和沮丧.我不知道最近发生了什么.我没有人要求或在任何地方寻求帮助所以我来到这里.

PDF警告:http://www.cs.uiuc.edu/class/sp08/cs473/Lectures/lec10.pdf

我不认为它有一个明确的解释,我肯定不明白.

我对正在发生的事情的理解是这样的:

我们有一组点(x1,y1),(x2,y2)..我们想找到一些最适合这些数据的线.我们可以有多条直线,这些线来自a和b的给定论坛(y = ax + b).

现在算法从末尾开始(？)并假设点p(x_i,y_i)是线段的一部分.然后笔记说最优解是'{p1,...的最优解...pi-1}加上(最佳)直线{pi ,. ..PN}".这对我来说意味着我们转到点p(x_i,y_i)并向后移动并通过其余点找到另一个线段.现在,最佳解决方案是这些线段.

然后它需要一个我无法遵循的逻辑跳转,并说"假设最后一个点pn是从p_i开始的段的一部分.如果Opt(j)表示前j个点和e(j,k)的成本通过点j到k的最佳线的误差然后Opt(n)= e(i,n)+ C + Opt(i-1)"

然后是算法的伪代码,我不明白.我知道我们想迭代点列表并找到最小化OPT(n)公式的点,但我不遵循它.这让我感到愚蠢.

我知道这个问题是一个痛苦的问题,并不容易回答,但我只是在寻找一些理解这个算法的指导.我为PDF道歉,但我没有更简洁的方式将重要信息提供给读者.

感谢您的时间和阅读本文,我很感激.

我有回收收集和协方差的问题,我想知道是否有人有更好的解决方案.

场景是这样的:

我有2个版本的实现,我想保持版本实现完全分离(即使它们可能具有相同的逻辑).在实现中,我想返回一个项目列表,因此在界面中,我将返回该项目的接口列表.但是,在实际的接口实现中,我想返回该项的具体对象.在代码中,它看起来像这样.

interface IItem
{
    // some properties here
}

interface IResult
{
    IList<IItem> Items { get; }
}

然后,将有2个名称空间具有这些接口的具体实现.例如,

命名空间版本1

class Item : IItem

class Result : IResult
{
    public List<Item> Items
    {
        get { // get the list from somewhere }
    }

    IList<IItem> IResult.Items
    {
        get
        {
            // due to covariance, i have to convert it
            return this.Items.ToList<IItem>();
        }
    }
}

在命名空间Version2下会有另一个相同的实现.

要创建这些对象,将有一个工厂接受版本并根据需要创建适当的具体类型.

如果调用者知道确切的版本并执行以下操作,则代码可以正常工作

Version1.Result result = new Version1.Result();
result.Items.Add(//something);

但是,我希望用户能够做到这样的事情.

IResult result = // create from …

我正在阅读ASP.NET MVC3的源代码,我在ControllerBase的代码中遇到了以下内容:

public interface IController
{
    void Excecute(RequestContext requestContext);
}


public abstract class ControllerBase : IController
{

    protected virtual void Execute(RequestContext requestContext)
    {
        if (requestContext == null)
        {
            throw new ArgumentNullException("requestContext");
        }
        if (requestContext.HttpContext == null)
        {
            throw new ArgumentException(MvcResources.ControllerBase_CannotExecuteWithNullHttpContext, "requestContext");
        }

        VerifyExecuteCalledOnce();
        Initialize(requestContext);

        using (ScopeStorage.CreateTransientScope())
        {
            ExecuteCore();
        }
    }

    void IController.Execute(RequestContext requestContext)
    {
        Execute(requestContext);
    }
}

ControllerBase提供了一个实现Execute,但它有一些提供...的定义IController.Execute？

为什么要这样做,它实现了什么？似乎没有任何意义.

检查以下两个代码块:

System.Security.AccessControl.DirectorySecurity dsec = System.IO.Directory.GetAccessControl(str);
System.Security.Principal.NTAccount group= new System.Security.Principal.NTAccount("DOMAIN","USERGROUP");
System.Security.AccessControl.FileSystemAccessRule myrule = new System.Security.AccessControl.FileSystemAccessRule(group,System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.AccessControlType.Allow);
dsec.SetAccessRule(myrule);
System.IO.Directory.SetAccessControl(str,dsec);

和

System.Security.AccessControl.FileSecurity fsec = System.IO.File.GetAccessControl(file);
System.Security.Principal.NTAccount group= new System.Security.Principal.NTAccount("DOMAIN","USERGROUP");
System.Security.AccessControl.FileSystemAccessRule myrule = new System.Security.AccessControl.FileSystemAccessRule(group,System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.AccessControlType.Allow);
fsec.SetAccessRule(myrule);
System.IO.File.SetAccessControl(file,fsec);

人们会期望他们两者完全相同,只有一个到目录,一个到文件.并且,在某些方面,他们这样做.在这两种情况下,有问题的文件系统对象都会更改,以使DOMAIN\USERGROUP具有完全控制的有效权限.

但是,奇怪的是,当您右键单击文件并查看安全性时,您会看到:

当您右键单击文件夹并查看安全性时,您会看到:

如果我然后转到高级 - >有效权限 - >选择(DOMAIN\USERGROUP),它会显示该组文件夹的有效权限是完全控制(选中所有框,而不仅仅是完整控制框那甚至更奇怪了.

我的问题是,为什么几乎相同的实现的效果有差异,有没有人知道如何复制应用权限到文件的效果？

尝试在不同的编译器上编译以下代码给我两个不同的结果:

struct S{};
struct T{S S;};
int main(){}

正如您所看到的,在内部T,我有一个与之前定义的类名称相同的对象S.

在GCC 4.7.2上,我收到与S S;内部声明有关的以下错误T:

错误:声明'ST :: S'[-fpermissive]
错误:从'struct S'改变'S'的含义[-fpermissive]

但是,将它移到课堂外(或进入main)可以正常工作:

struct S{};
S S;
int main(){}

它给我的错误究竟是什么意思？

在Visual Studio 2012中,整个事件编译并运行没有任何错误.将它粘贴到这个Clang 3.0编译器中也没有错误.

哪个是对的？我真的可以这样做吗？

我一直在努力学习编程.我研究过Java和Python,我对它们的语法很满意.最近,我想利用我从头开始编写有形软件所学到的知识.

我想实现一个数据库引擎,一种NoSQL数据库.我整理了一个小文档,在我编写代码的过程中遵循的规范.但我所知道的只是一堆关键词.我不知道从哪里开始.

有人可以帮我找到如何收集这种工作所需的知识以及学习东西的顺序吗？我搜索了文档,但我觉得我最终会找到无关/错误的内容或从错误的点开始,因为实现一个完整的数据库引擎(似乎是)一个真正复杂的任务.

我不想表达我更喜欢论文和白皮书以及(e)书籍到其他项目的代码,因为我已经问过一个人们通常会以"阅读项目 - x"的形式得到回答的问题.源代码".我没有达到舒适阅读和理解源代码的水平.

我刚刚遇到一种行为,我首先认为它是Eclipse中的一个错误.考虑这个简单的类:

public class Foo {
    public static interface Callback {
        public void onAction();
    }
}

这完全有效.但是,这不是:

public class Foo implements Callback {
    public static interface Callback {
        public void onAction();
    }

    public void onAction() { /*some implementation*/ }
}

但这也是有效的:

public class Foo {
    public static interface Callback {
        public void onAction();
    }

    private final Callback mCallback = new Callback() {
        public void onAction() { /*some implementation*/ }
    };
}

为什么Java迫使我"浪费"一个成员,如果它可以通过让我自己实现它来简单地保存它？我非常清楚将此接口放在自己的文件中的"解决方法",但出于好奇:有没有理由说这不起作用？