标签: using

据我所知,Using语句内置了Dispose()和Try-Catch的实现.所以我想知道一些事情

1. 是否可以在语句内部或外部使用语句记录异常而不使用try-catch块.如果没有,那么为什么它内置于声明中.

2. 嵌套或过度使用try-catch不是首选,那么为什么这种模型更喜欢使用.

           using (some_resource)
           {
               try
               {
               }
               catch
               {
               }
               finally
               {
                   //my exception logging mechanism
               }
           }
   

   Run Code Online (Sandbox Code Playgroud)

会变成

            try
            {
                try
                {
                }
                catch
                {
                }
                finally
                {
                    //my exception logging mechanism
                }
            }
            catch
            {
            }
            finally
            {
                //some_resource.Dispose()
            }

编辑: - 如何确保StringBuilder在多线程环境中对象是GC？(鉴于我不能使用使用关键字)？

我正在使用StringBuilder多个线程,并StringBuilder为每个被调用的线程创建一个新实例.

我关注的是性能,特别是它为StringBuilder创建这么多实例所占用的内存.

有没有其他方法可以确保GC为我释放内存？(比如调用Dispose等)

编辑:StringBuilder没有实现IDisposable,所以我不能使用using关键字.

编辑:我不想强迫,GC.Collect()因为有多个线程同时运行,他们在它们之间共享资源.其中一些线程处于休眠状态,只是监听事件再次变为活动状态.

我有这个方法

public static List<_Account> Get(_User user, string name = null, SearchType sName = SearchType.Equals)
{
  using (Context context = new Context())
  {
    IQueryable<_Account> query = context.Accounts;
    if (!string.IsNullOrEmpty(name) && sName == SearchType.Equals)
      query = query.Where(r => r.Name.Equals(name));
    if (!string.IsNullOrEmpty(name) && sName == SearchType.StartsWith)
      query = query.Where(r => r.Name.StartsWith(name));
    if (!string.IsNullOrEmpty(name) && sName == SearchType.Contains)
      query = query.Where(r => r.Name.Contains(name));
    return query.ToList();
  }
}

这有效，但是当我从另一个方法调用此方法时，我已经定义了一个上下文，我想重用该上下文。我会添加一个可选参数

public static List<_Account> Get(..., Context ctx = null) {...

如果ctx != null我希望使用该上下文而不是在最后处理。否则，我希望在 …

为了使用字符串,我需要包含字符串头,以便它的实现可用.但如果是这样,为什么我仍然需要添加线using std::string？

为什么它不知道字符串数据类型？

#include <string>

using std::string;

int main() {
    string s1;
}

     using (var db1 = new DataBase1Entities())
        {
           using (var db2 = new DataBase2Entities())
           {
                var list = (from obj in db2.Table1
                            where !db1.Table2.Any(i => i.Table2Col == obj.Table1Col)
                            select obj).ToList();
           }
        }

有谁知道如何从一个数据库表中检索值并将其与另一个数据库表进行比较？如果上面的代码是正确的，那么会导致性能问题吗？

假设我有一个带有方法的字符串类ToStream()。

class FooBar
{
    pubic Stream ToStream( )
    {
        byte[ ] barFooBytes = Encoding.UTF8.GetBytes( this.BarFoo );
        return new MemoryStream( barFooBytes );
    }
}

现在假设我有一个班级正在获取此流。

class BarFoo
{
    pubic void DoCrazyStuff( )
    {
        using( Stream fooBarStream = ( new FooBar( ) ).ToStream( ) )
        {
            // Doing some really crazy stuff!
        }
    }
}

using使用创建流的方法外部仍然有意义吗？

提示： 这不是真实的现实生活场景。这是一个纯粹的技术问题。因此，这段代码被缩小只是为了澄清问题。

我希望我的 Visual Studio #CS 编辑器更喜欢在 using 语句中使用完全限定的命名。所以我更喜欢：

using myproject.management.control.common;

而不是

using control.common;

Resharper中有这样一个选项“在嵌套范围内首选使用完全限定的名称”。

.editorconfig 文件中的并行设置是什么？

如果我在类或结构中使用typedef或using，有时我希望它独立于用于该类或结构的模板。

在下面的示例中，我会使用Object<T>::RefCountT, 这会起作用，但我宁愿Object::RefCountT在这种情况下使用类似的东西，因为那样我就不必随意选择一种类型（这在阅读时可能会造成混淆）。

template <typename T>
struct Object {
    using RefCountT = unsigned short; // This is independent of T
};

对我来说，显而易见（但不理想）的解决方案是在课堂之外定义它，比如

using ObjectRefCountT = unsigned short;

我还尝试在没有模板的情况下进行重新定义，假设它们不会被认为是相同的，但这导致了关于重新定义的预期错误。

我假设因为它是一个类而不是一个函数，所以我不能隐式地这样做，编译器怎么知道它在这里无关紧要？

我想创建一个类型别名array_t。它应该适用于有界和无界数组。我可以像这样为每个案例分别声明它：

// Type of an unbounded array of `T`
template <typename T>
using array_t = T[];
// Type of an array of `T` of size `Size`
template <typename T, size_t Size>
using array_t = T[Size];

问题是两者不能同时声明。我认为解决方案可能是使用某种模板专业化，但我不确定在这种情况下如何使用它。

我正在尝试在 Visual Studio 2019 中创建自定义模板项目。在我的模板中，项目指令应该位于命名空间内。在编码时我把它们放在里面。但是当项目生成时，我在外面看到它们（我的代码被覆盖）。

如何让 Visual Studiousing在使用自定义项目模板创建的每个新项目的命名空间中放置语句？