Andrey K.'s questions

您能告诉我如何通过按钮/命令从 tt-templates (t4) 更新/开始代码生成吗？

• 此外，我希望将更新机制与解决方案绑定（即在另一台机器上的另一个工作室中打开解决方案时，使该机制保持在附近，以便您可以通过单击按钮/命令开始生成无论如何，即使在另一台机器上，没有预设/设置[更新：划掉设置选项，因为从工作室调用自定义工具的选项可能适合你，如果这个工具和你在一起]）

• 构建期间的代码生成不太合适，因为 生成本身可能需要半分钟（大约不是本质），每次构建的这种延迟是不可取的，因为生成是必要的，相对很少

• 这里有一个自启动选项TextTransform.exe（以编程方式运行 T4）；但是这个选项的问题是代码生成使用EnvDTE.DTE（据我了解，这是视觉工作室本身的对象，例如，您可以使用它来解析已经编写的项目代码）；TextTransform.exe当从工作室以外的地方调用时，这个EnvDTE.DTE将是= null，然后模板代码将不起作用

    // UPD: код, который дает Null reference exception 
    // когда вызывал TextTransform.exe из своего консольного приложения
    var visualStudio 
        = (this.Host as IServiceProvider)
        .GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;

• 解决方案中有几个这样的模板（比如说10个，不是本质）；现在，要更新，我打开每个模板，在评论中的某处添加一个空格（以便更改文件）；保存修改后的文件时，会调用代码生成。原则上，这样的解决方案是可以接受的，但并不美观，我不确定同事是否会批准

• Upd （附加解释） ：这意味着同事可以自己生成代码，并且他们不会有不简单的第一印象......一个项目中的两个接口（public interface IService和）可以说是基于模型的public interface IServiceCallback在其上生成代码。对于同事，你需要编写说明如何编辑这些接口，以及如何使代码生成。如果指令描述一个用于更新代码的命令会更好。使添加代码尽可能简单。

问题不在于如何漂亮地编程以使这个问题不会出现，而是关于一个漂亮的包装器try-catch。

try
{

}
catch 
{
    // здесь ничего нет
}

• 这是一件好事，但它占用了大量空间，我希望它可以放在一个块中，但执行相同的功能

我正在制作一段代码，它是一个安全网，根本不值得太多关注（现在我只关注未来，因为我已经不止一次地考虑过这个问题，好吧，放松一下）。优雅地重构是不值得的。你需要简单快速地说出来try，但我希望它看起来很漂亮。如果某些东西在那里不起作用，那没关系，但我也希望它不要在重要的地方出现异常，所以问题是关于try-catch.

有一个选项可以创建一个方法：

private void Try(Action codeBlock)
{
    try
    {
        codeBlock?.Invoke();
    } 
    catch 
    {
    } 
}

那么呼叫将在一行中，但此选项不是 100%，例如：

• 这似乎不是一个美丽的挑战Try( ()=>DoWork() );，我想要更简单的东西，没有花里胡哨

• 您可以将方法调用直接传递到参数Try(MethodCall)中，它看起来已经更好了，但是在我的特殊情况下，我将不得不将这个安全网和次要的方法分成许多部分，例如，如果情况是这样的：

  private static void EnsureSomethingWhichFailsAnyway(Someting input)
  {
      try
      {
          foreach (var x in input.GetAllX())
          {
              DoSmallThing(x);
              try
              {
                  x.SetPropertyValue = PossibleValues.BigValue;
              }
              catch { }
          }
      } catch { }
      try
      {
          foreach (var y in input.GetllY())
          {
              try
              {
                  y.Validate(StaticVars.A, StaticVars.B, StaticVars.C);
              }
              catch { }
          }
      }
      catch { }
  }
  

• 也就是说，如果你把这样的方法分解成子方法来调用类型，Try(MethodCall)那么游戏就得不偿失了。

• 有可能以某种方式放入using吗？

• 也许没有理想的解决方案，那么只是听到建设性的想法很有趣。

谢谢！

如何有效地为.Net Core, Framework,创建兼容性垫片Standard？

版本： Framework 4.6.1 ; Core 2.0; Standard 2.0.

例如，以下 3 件事很有趣，可以在.net core和.net standard之间使用.net framework：

System.Windows.Threading.Dispatcher……System.ComponentModel.ItemPropertyInfo.Descriptor甚至 System.Windows.Controls.MenuItem……

事实上，看起来需要更多这些外壳。当然，它们可以手动创建。但也许有一种更有效的方法来避免机械工作？

如果手动完成，则以粗略的示例说明任务：

例如，Core 2.0没有为Dispatcher.

制作了一个抽象包装器/接口/外观，：

public enum DispatcherShimPriority
{
    Background
    //...
}

public interface DispaicherShim
{
    void Invoke(Action action, DispatcherShimPriority prio);
    void BeginInvoke(Action action, DispatcherShimPriority, prio);
}

这里有2个实现：

public class DispatcherCore: DispaicherShim;
//здесь по началу можно просто вызывать Action

和

public class DispatcherFramework: DispaicherShim;
//здесь используется реальный Dispatcher внутри

接下来，制作了某种多用途的激活器类，例如，Shims其中：

public static DispaicherShim CreateDispatcher()
{
#if NETCOREAPP2_0
    return new DispatcherCore();
#else
    return new DispatcherFramework();
#endif       
}

因此，获得了可用于框架和核心应用程序的外壳。

创建这样的外壳需要大量的机械工作。直觉上，在我看来，没有必要做这项工作，有现成的解决方案......

了解Microsoft.Windows.Compatibility包。我的意思是为该包未涵盖的元素创建包装器。

我听说过Microsoft.Windows.Compatibility.Shims，但我怀疑对于包本身未涵盖的元素没有包装器。

总体目标是将 WPF 应用程序的主体转换为潜在 Web 客户端的核心（留下工作的 WPF），尽管主体的 .net 框架的许多元素并未转换为核心。

创建了一个库.net-standard，在其中定义了一个类Class1和一个常量MyConst。

接下来，我创建了一个控制台应用程序.net-core，在其中我草绘了以下代码：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(Class1.MyConst);
        Console.ReadLine();
    }
}

就我而言，.Net Standard 是 1.3 版，.Net Core 是 1.0 版。

UPD：工作室版本：Microsoft VS Enterprise 2017 v. 15.4.0

(!) 问题是无法启动控制台应用程序。控制台闪烁大约一毫秒，但没有按预期运行，也就是说，它没有输出包含“Hello world”的常量，也没有停止在Console.ReadLine();.

输出中显示以下信息：

Программа "[8376] dotnet.exe" завершилась с кодом -2147450749 (0x80008083).
Программа "[8376] dotnet.exe: Трассировка программы" завершилась с кодом 0 (0x0).

嗯，是的，从图片中您可以看到库.net-standard（其中的类Class1，其中的常量MyConst）也可以从 WPF 应用程序（.Net Framework 4.6）访问。在这里，我添加了 nuget 包，库的链接工作正常，即应用程序启动并显示常量。我认为这方面与主题无关。

谢谢

我对R编程语言不是很熟悉，有没有可能做一个这样的系统？

假设有一个用 R 编写的模块。对于它，应该沿途形成一组输入数据。在什么情况下，这些数据是通过 C# 形成的。接下来，调用这个 R 模块，它会生成一个报告，例如一些数据。此数据显示在 WPF GUI 上，即 WPF 在其某些控件中显示 R 标记或某些 R 图形。那么有可能吗？

第二个问题，同时。是否可以使用 C# 使 R 输入动态更新，以便 WPF 界面上的图形动态更新？

谢谢。

PS：我会尝试开始比赛。理想情况下，我会对解决方案的简短或详细描述感到满意，而不仅仅是解释为什么是或为什么不是。

Upd：我在很久以后添加了我自己关于闪亮的答案，所以纯粹通过投票来判断是不客观的。你甚至可以看看我的回答。

是否可以一次使用System.Diagnostics.Trace.WriteLine()日志记录到多个文件？我希望日志不是写在一个堆中，而是逻辑上分成不同的文件。就我而言，系统包含约 5 个不同对象的列表（不管是哪个对象）。我希望这些对象中的每一个在单独的文件中都有自己的单独日志。

如果这是不可能的，那么“System.Diagnostics.Trace.WriteLine()不允许这样做”的简短回答就足够了。然后我会看看NLog或log4net，我猜。但是那里（在Trace() -e 中）有某种开关......我还没有弄清楚。

谢谢。

对不起，恐怕无法明确提出问题并显示代码示例。

情况：

一旦我有这样的方法返回IEnumerable<T>，同时，在某个时候，当使用 help 遍历元素时foreach，结果证明元素不再存在（好像是IEnumerable<T>空的）。尽管事实上该方法最初返回了一个非空列表。

//Допустим, метод GetElements() возвращает не пустой IEnumerable<Element>
var elements = SomeStaticClass.GetElements();

//затем не помню что происходит

//в итоге
foreach (var element in elements)
{
    //сюда не разу не зашли
}

也就是说，在某些情况下，它IEnumerable<T>只是一个枚举器，已经没有数据了。

但是，如果您先执行此操作GetElements().ToArray()，则不再观察到此类问题。

//Допустим, метод GetElements() возвращает не пустой IEnumerable<Element>
var elements = SomeStaticClass.GetElements().ToArray(); //!!!!!

//затем не помню что происходит

//в итоге
foreach (var element in elements)
{
    //сюда зашли много раз
}

问题：

在什么情况下会发生这种情况？知道这一点很有用，以免每次都产生ToArray()，即使没有必要。

告诉我为什么我的控件变慢了，尽管它是从并行线程调用的。

我正在尝试为.NET 4.0 ( HighlightTextBlock )创建一个控件，它将以黄色突出显示子文本。这个想法是，如果找到子文本，则ContentControl的Content变成3 Runs的TextBlock ，其中一个以黄色突出显示。

• result.Add(new Run(stringBefore));

• result.Add(new Run(stringMatch) { Background = this.HighlightBrush });

• result.Add(new Run(stringAfter));

如果未找到子文本，则仅插入文本。

一切都已经证明并有效，但问题在于性能。

我将更详细地描述：

此控件用于可能有数百条记录的工作表中。子文本在TextBox中编辑。绑定到这个文本框如下：HighlightText = "{Binding ElementName=myTextBox, Path=Text}"。如果您编辑此子文本，它会冻结，光标会“跳动”，如图所示。对于每次击键，都会执行代码以突出显示文本，并且很明显它在我的控制下已经减慢了 30 行。

擦除时，文本应该平滑地淡化，但不是很平滑：

在我的控制范围内，我试图这样做：

Dispatcher.BeginInvoke(
(ThreadStart)delegate
{
    //update control
}
);

因此，通过异步：

Task.Factory.StartNew(/*поиск в строке и разбиение строки на 3 части*/)
    .ContinueWith(
        x =>
        {
            //update control
        }
        ,TaskScheduler.FromCurrentSynchronizationContext()
        );

但是不可能摆脱刹车。

您可以检查一个简单示例的控件（我立即手写）。制动已经发生在 30 行。

<TextBox Name="myTextBox"/>
<ItemsControl>
    <ItemsControl.Items>
        <!-- ... -->
        <controls:HighlightTextBlock Text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" HighlightText = "{Binding ElementName=myTextBox, Path=Text}"/>
        <controls:HighlightTextBlock Text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" HighlightText = "{Binding ElementName=myTextBox, Path=Text}"/>
        <controls:HighlightTextBlock Text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" HighlightText = "{Binding ElementName=myTextBox, Path=Text}"/>
        <controls:HighlightTextBlock Text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" HighlightText = "{Binding ElementName=myTextBox, Path=Text}"/>
        <controls:HighlightTextBlock Text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" HighlightText = "{Binding ElementName=myTextBox, Path=Text}"/>
        <controls:HighlightTextBlock Text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" HighlightText = "{Binding ElementName=myTextBox, Path=Text}"/>
        <controls:HighlightTextBlock Text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" HighlightText = "{Binding ElementName=myTextBox, Path=Text}"/>
        <!-- ... -->
    </ItemsControl.Items>
</ItemsControl>

这是承诺的完全控制代码。无论有没有调试器，它都会变慢。

public class HighlightTextBlock : ContentControl
{

    public string Text
    {
        get { return (string)GetValue(TextProperty); }
        set
        {
            SetValue(TextProperty, value);
        }
    }

    public static readonly DependencyProperty TextProperty =
        DependencyProperty.Register("Text", typeof(string), typeof(HighlightTextBlock), new UIPropertyMetadata("", new PropertyChangedCallback(TextProperty_PropertyChanged)));

    private static void TextProperty_PropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = d as HighlightTextBlock;
        control.SetContent();
    }



    public string HighlightText
    {
        get { return (string)GetValue(HighlightTextProperty); }
        set
        {
            SetValue(HighlightTextProperty, value);
        }
    }

    public static readonly DependencyProperty HighlightTextProperty =
        DependencyProperty.Register("HighlightText", typeof(string), typeof(HighlightTextBlock), new UIPropertyMetadata("", new PropertyChangedCallback(HighlightTextProperty_PropertyChanged)));

    private static void HighlightTextProperty_PropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = d as HighlightTextBlock;
        control.SetContent();
    }

    public Brush HighlightBrush
    {
        get { return (Brush)GetValue(ColorProperty); }
        set { SetValue(ColorProperty, value); }
    }

    public static readonly DependencyProperty ColorProperty =
        DependencyProperty.Register("HighlightBrush",
        typeof(Brush),
        typeof(HighlightTextBlock),
        new UIPropertyMetadata(Brushes.Orange));


    static HighlightTextBlock()
    {
        //DefaultStyleKeyProperty.OverrideMetadata(typeof(ContentControl), new FrameworkPropertyMetadata(typeof(ContentControl)));
    }


    private TextBlock TextContent
    {
        get { return Content as TextBlock; }
        set { Content = value as TextBlock; }
    }


    public HighlightTextBlock()
    {
        TextContent = new TextBlock();
        SetContent();
    }

    private void SetContent()
    {

        //TextContent.Text = Text;

        var tmpText = Text;
        var tmpHighlightText = HighlightText;
        /*Task.Factory.StartNew<CombinedText>(() => GetCombined(txt, hghlghtTxt))
            .ContinueWith(
                x =>
                {
                    Debug.WriteLine("------- XXXXXXXX -------");
                    var text = (CombinedText)x.Result;

                    TextContent = new TextBlock();
                    TextContent.Inlines.Add(new Run(text.Before ?? ""));
                    TextContent.Inlines.Add(new Run(text.Match ?? "") { Background = HighlightBrush });
                    TextContent.Inlines.Add(new Run(text.After ?? ""));

                    Debug.WriteLine("---------ZZZZZZZZ------------");
                }
                ,TaskScheduler.FromCurrentSynchronizationContext()
            );*/

        Dispatcher.BeginInvoke(
            (ThreadStart)delegate
            {
                var text = GetCombined(tmpText, tmpHighlightText);
                TextContent = new TextBlock();
                TextContent.Inlines.Add(new Run(text.Before ?? ""));
                TextContent.Inlines.Add(new Run(text.Match ?? "") { Background = HighlightBrush });
                TextContent.Inlines.Add(new Run(text.After ?? ""));
            }
            );
    }

    private CombinedText GetCombined(string text, string highlightText)
    {
        Debug.WriteLine("------------1111---------------");
        var result = new CombinedText();
        SharpDebug.WriteLine(text);
        SharpDebug.WriteLine(highlightText);

        if (text != null && highlightText != null)
        {
            Debug.WriteLine("-----------2222----------------");
            var queryLength = highlightText.Length;
            var sourceLength = text.Length;

            var index = text.IndexOf(highlightText, StringComparison.InvariantCultureIgnoreCase);

            if (index >= 0)
            {
                Debug.WriteLine("-------------3333--------------");
                var stringBefore = text.Substring(0, index);
                var stringMatch = text.Substring(index, queryLength);
                var stringAfter = text.Substring(index + queryLength, sourceLength - (index + queryLength));

                if (stringBefore.Length > 0)
                {
                    Debug.WriteLine("-------------4444--------------");
                    result.Before = stringBefore;
                }

                if (stringMatch.Length > 0)
                {
                    Debug.WriteLine("------------5555---------------");
                    result.Match = stringMatch;
                }

                if (stringAfter.Length > 0)
                {
                    Debug.WriteLine("-------------6666--------------");
                    result.After = stringAfter;
                }

                Debug.WriteLine("------------7777---------------");
                return result;
            }
        }
        Debug.WriteLine("-------------9999--------------");

        result.Before = text;
        return result;
    }
}

internal struct CombinedText
{
    public string Before { get; set; }
    public string Match { get; set; }
    public string After { get; set; }
} 

internal static class ControlExtensions
{
    public static void Clear(this TextBlock text)
    {
        text.Text = "";
    }
}

将 .Net Framework 引用添加到项目中是否会使项目明显变重？还是明显变慢了？还是有害的？

我指的是.Net Framework中包含的那些程序集。

为了以防万一，我会解释原因。有一小段代码只能在Debug 模式下运行。这一段是我随意加的，团队里没有人问过我。如果他们发现了，他们可能会要求移除。但这让我的生活变得轻松多了，但我不想每次都删除和添加，不方便。为了让这篇文章起作用，您需要从.Net Framework加载几个reference。这篇文章不涉及发布，但参考文献仍然存在。为了简化生活，我什至会在发布版本中保留这些引用，尽管它们没有在其中使用。但它有多重要？这不会对发布有任何不利影响吗版本？