标签: using

D在某些结构两次继承另一个结构的情况下A：一次是私有的 via B，第二次是公开的 via C，是否允许using B::A写入D？

struct A {};
class B : A {};
struct C : A {};
struct D : B, C { 
    using B::A;  //ok in GCC, error in Clang
};

该程序被 GCC 接受，但 Clang 打印错误：

error: 'A' is a private member of 'A'

演示： https: //gcc.godbolt.org/z/5jeqrzorE

using B::A必须只暴露注入的类A名D。一方面，A它已经可以在 in 中使用D（因此 GCC 接受它），但另一方面它A是私有的B（因此 Clang 拒绝它）。这里是哪一个编译器？

我理解"使用"的意思是保证调用对象的Dispose方法.但是如何处理"使用"语句中的异常呢？如果有异常,我需要在try catch中包装我的"using"语句.例如:

可以说在using参数中创建对象时会创建一个异常

 try
 {
    // Exception in using parameter
    using (SqlConnection connection = new SqlConnection("LippertTheLeopard"))
    {
       connection.Open();
    }
 }
 catch (Exception ex)
 {

 }

或使用范围内的异常

 using (SqlConnection connection = new SqlConnection())
 {
    try
    {
       connection.Open();
    }
    catch (Exception ex)
    {

    }
 }

好像我已经需要使用try catch来处理异常,也许我应该只处理对象的处理.在这种情况下,"使用"声明似乎并没有帮助我.如何使用"using"语句正确处理异常？我错过了更好的方法吗？

 SqlConnection connection2 = null;
 try
 {
    connection2 = new SqlConnection("z");
    connection2.Open();
 }
 catch (Exception ex)
 {

 }
 finally
 {
    IDisposable disp = connection2 as IDisposable;
    if (disp != null)
    {
       disp.Dispose();
    }
 }

"使用"关键字语法可能会更加含糖......
这肯定会很好: …

我正在使用using语句中的using语句返回我正在创建的变量(听起来很有趣):

public DataTable foo ()
{
    using (DataTable properties = new DataTable())
    {
       // do something
       return properties;
    }
}

这将Dispose属性变量??

这样做后我仍然得到这个警告:

警告34 CA2000:Microsoft.Reliability:在方法'test.test'中,在对所有对它的引用超出范围之前,对对象'properties'调用System.IDisposable.Dispose.

有任何想法吗？

谢谢

免责声明:我是开发人员,而不是DBA.

我一直是Oracle中USING子句的忠实粉丝,因为我不小心偶然发现它并且用它来代替老式的ON子句从那时起就将事实表与维度表连接起来.对我来说,它创建了一个更简洁的SQL,并生成了更简洁的结果集,没有不必要的重复列.

但是,昨天我被一位同事要求将我的所有USING条款转换为ON.我会和他核实一下,问他原因是什么.他与数据库的工作比我更密切,所以我认为他有一些很好的理由.

我没有收到他的回复(我们在不同的时区工作),但我想知道是否有关于使用"使用"条款的指导方针或最佳做法？我已经搜索了很多,但没有找到任何确定的东西.事实上,我甚至都没有在任何地方进行过很好的辩论.

有人可以对此有所了解吗？或者提供一个关于该主题的良好讨论的链接？

谢谢!

我想知道为什么我们using在C#中使用语句.我查了一下,发现它用于执行语句然后清理对象.所以我的问题是:如果我们打开并关闭花括号({ })来定义范围,那不是一回事吗？

使用声明:

using (SqlConnection conn = new SqlConnection(connString)) {
     SqlCommand cmd = conn.CreateCommand();
     cmd.CommandText = "SELECT * FROM Customers";
     conn.Open();
     using (SqlDataReader dr = cmd.ExecuteReader()) {
          while (dr.Read()) 
          // Do Something...
     }
}

大括号:

{
     SqlConnection conn = new SqlConnection(connString);
     SqlCommand cmd = conn.CreateCommand();
     cmd.CommandText = "SELECT * FROM Customers";
     conn.Open();
     {
          SqlDataReader dr = cmd.ExecuteReader();
          while (dr.Read()) 
          // Do Something...
     }
}

两种方法之间是否存在显着差异？

我无法理解为什么Program.Fetch1,Program.Fetch2也不会导致完全相同的执行顺序.唯一的区别是Program.Fetch1调用Program.Fetch实际的获取操作.

class Program
{
    static IEnumerable<int> Fetch1()
    {
        using (Context c = new Context())
        {
            return Fetch(c);
        }
    }

    static IEnumerable<int> Fetch(Context c)
    {
        foreach (int i in c.Fetch())
        {
            yield return i;
        }
    }

    static IEnumerable<int> Fetch2()
    {
        using (Context c = new Context())
        {
            foreach (int i in c.Fetch())
            {
                yield return i;
            }
        }
    }

    static void Main(string[] args)
    {
        Console.WriteLine("Fetch1:");
        foreach (int i in Fetch1())
        {
            Console.WriteLine(i);
        } …

我放弃了,请帮助解释一下这种行为.我在下面给出的例子是我能想到的最简单的例子,但它总结了这个问题(在Cygwin上使用g ++ 4.9.2并启用了c ++ 14).我想创建一个类似于的类std::mem_fn.这是我的班级:

template <class R, class T, R(T::*P)() const >
struct property {

    static R get(const T& t) {
        return (t.*P)();
    }
};

R返回类型在哪里,是T我感兴趣的对象的类型.第三个模板参数是指向成员函数的指针.到现在为止还挺好.

然后我创建一个包含如下整数的简单类

class data_class {

public:

    unsigned get_data() const {
        return m_data;
    }

private:
    unsigned m_data;
};

这是将在property之前显示的类中使用的类.

现在我创建两个继承自data_class以下的类

struct my_classA
: public data_class {

    using data = property<unsigned, data_class, &data_class::get_data>;
};

//same as my_classA, only templated
template <int I>
struct my_classB
: public data_class …

我有一个采用模板类型参数(tTRAIT)的类.我想知道tTRAIT 的模板类型 成员 别名,但我无法弄清楚语法.(这有可能吗？).

template <bool bBOOL>
struct SFoo {};

struct STrait
    {
        template <bool bBOOL>
        using TFoo = SFoo<bBOOL>;
    };

template <typename tTRAIT>
struct SBar
    {
        template <bool bBOOL>
        friend typename tTRAIT::template TFoo<bBOOL>;
    };

SBar<STrait> bar;

Clang的错误(friend在线)是:

error: friend type templates must use an elaborated type

我试过用尽我能想到的所有可能的组合:

friend tTRAIT::TFoo;
friend tTRAIT::template TFoo;
friend typename tTRAIT::TFoo;
friend typename tTRAIT::template TFoo;
template <bool bBOOL> friend tTRAIT::TFoo;
template <bool bBOOL> friend tTRAIT::TFoo<bBOOL>;
template <bool bBOOL> friend tTRAIT::template TFoo; …

我刚刚开始使用resharper,它在这个生成的assemblyinfo.cs文件中咆哮.

Reason/Logic告诉我,我可以把它排除在外,因为它是resharper的最新版本,它是一个流行的工具.

我的担心与我的有限理解有关,这与新的c#特征的相互作用,例如扩展方法结合使用似乎没有"使用"的"使用".

希望这有点道理.

这是为了清晰起见屏幕截图.

我正在尝试测试我班级的受保护方法和构造函数.为此,我尝试将其子类化,并使用C++ 11 using关键字将其成员重新导出为public :

class Foo {
  protected:
   Foo(int i) {}
   void run() {}
};

class TestableFoo : public Foo {
  public:
   using Foo::Foo;
   using Foo::run;
};

int main() {
  TestableFoo foo(7);
  foo.run();
}

但是,g ++和clang ++都无法编译它,产生以下错误:

test.cpp:13:15: error: ‘TestableFoo::TestableFoo(int)’ is protected
    using Foo::Foo;
               ^
test.cpp:18:16: error: within this context
   TestableFoo foo(7);
                    ^

即使run方法公开(我单独确认),TestableFoo构造函数仍然受到保护.为什么会这样？我可以理解决策(继承与覆盖可见性),但为什么方法和构造函数之间存在不一致？