小编Tho*_*que的帖子

我需要使用Json.NET将一些实体类序列化为JSON.为了自定义属性的名称,我使用如下[JsonProperty]属性:

    [JsonProperty("lastName")]
    public string LastName { get; set; }

问题是,我不希望在我的实体中没有任何与JSON相关的属性......是否有办法以某种方式外化注释,以便它们不会使我的实体混乱？

使用XmlSerializer,可以在XmlAttributeOverrides课堂上轻松完成.Json.NET有类似的东西吗？

这里的value关键字是什么以及如何将值分配给_num？我很困惑,请给出以下代码的说明.

    private int _num;
    public int num
    { 
        get 
        {
            return _num;
        }
        set 
        {
            _num=value;
        }
    }

    public void button1_click(object sender,EventArgs e)
    {
        num = numericupdown.Value;
    }

我正在使用C#和.NET Framework 4.7将Entity Framework 6.1.3 Code First库迁移到Entity Framework Core.

我一直在搜索有关Google的实体框架核心,但我没有找到很多关于它的信息,所以我试着自己做.

在Entity Framework 6.1.3上我有这个配置类:

using System.Data.Entity.ModelConfiguration;

namespace MyProject.Data.SqlServer.Configurations
{
    class AggregationChildrenConfiguration : EntityTypeConfiguration<AggregationChildren>
    {
        public AggregationChildrenConfiguration()
        {
            HasKey(ag_ch => ag_ch.AggregationChildrenId);

            HasRequired(ag_ch => ag_ch.Aggregation)
                .WithMany(ag => ag.AggregationChildren)
                .HasForeignKey(ag_ch => ag_ch.AggregationId);

            HasRequired(ag_ch => ag_ch.Code)
                .WithOptional(c => c.AggregationChild)
                .WillCascadeOnDelete(false);
        }
    }
}

我已迁移到这个:

using DataLibrary;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace BusinessLibrary.Configurations
{
    class AggregationChildrenConfiguration : IEntityTypeConfiguration<AggregationChildren>
    {
        public void Configure(EntityTypeBuilder<AggregationChildren> builder)
        {
            builder.HasKey(ag_ch => ag_ch.AggregationChildrenId);

            builder.HasRequired(ag_ch => ag_ch.Aggregation)
                .WithMany(ag => ag.AggregationChildren)
                .HasForeignKey(ag_ch => ag_ch.AggregationId); …

我正在寻找一种动态添加成员动态对象的方法.好的,我想需要一点澄清......

当你这样做:

dynamic foo = new ExpandoObject();
foo.Bar = 42;

该Bar属性将在运行时动态添加.但代码仍然"静态"引用Bar(名称"Bar"是硬编码的)...如果我想在运行时添加属性而不知道它在编译时的名称怎么办？

我知道如何使用类的方法使用自定义动态对象(我实际上是几个月前的博客)DynamicObject,但是如何使用任何动态对象？

我可以使用IDynamicMetaObjectProvider界面,但我不明白如何使用它.例如,我应该将哪个参数传递给GetMetaObject方法？(它期待一个Expression)

顺便说一句,你如何对动态对象进行反射？"定期"反思TypeDescriptor并不显示动态成员......

任何见解将不胜感激!

我正在尝试以编程方式在WPF控件上手动触发MouseLeftButtonDown事件,因为我使用的是Microsoft Surface SDK,它不会触发MouseLeftButtonDown事件,而是触发ContactDown事件.基本上我正在尝试将MouseLeftButtonDown事件向下推送到控件,以在处理ContactDown事件时触发控件上的正确行为.

我猜我必须以某种方式使用控件上的RaiseEvent方法来实现MouseButtonEventArgs,但是我在查找参数时遇到了一些麻烦.

在此先感谢您的帮助!

我使用Entity Framework 4.2(代码优先)将大量数据插入到SQL Server CE 4.0中,与直接SQL插入相比,性能极差.

该模型非常简单:

public class DocMember
{
    public DocMember() { this.Items = new List<DocItem>(); }

    public int Id { get; set; }

    public string Name { get; set; }
    public string MemberType { get; set; }
    public string AssemblyName { get; set; }

    public virtual IList<DocItem> Items { get; set; }
}

public class DocItem
{
    public int Id { get; set; }
    public DocMember Member { get; set; }
    public string PartType { get; set; …

我有几个类依赖于类ILogger.实现ILogger需要知道它是记录器的类型,即ILoggerfor Foo将是new Logger(typeof(Foo)),因为Bar它将是new Logger(typeof(Bar)),等等.

我希望Unity自动注入合适的记录器; 换句话说,当我打电话时container.Resolve<Foo>(),我希望将a new Logger(typeof(Foo))注入到Foo实例中.

如何在Unity中进行设置？有没有办法将被解析的类型传递给依赖项？

(在我真正的代码,我其实有ILoggerFactory一个Create方法,这也需要一个类型作为参数,所以我可以在工厂只是传递给我的课,他们会叫Create自己能得到相应的记录仪,但它不是那么优雅正如我想要实现的那样)

一些代码使事情更清晰:

interface ILogger
{
    ...
}

class Logger : ILogger
{
    private readonly Type _type;
    public Logger(Type type)
    {
        _type = type;
    }
    ...
}

class Foo
{
    private readonly ILogger _logger;
    public Foo(ILogger logger) // here I want a Logger with its type set to …

我刚刚发现Entity Framework中的延迟加载只能从创建它的线程中运行ObjectContext.为了说明这个问题,我做了一个简单的测试,只有一个包含2个实体的简单模型:Person和Address.这是代码:

    private static void TestSingleThread()
    {
        using (var context = new TestDBContext())
        {
            foreach (var p in context.Person)
            {
                Console.WriteLine("{0} lives in {1}.", p.Name, p.Address.City);
            }
        }
    }

    private static void TestMultiThread()
    {
        using (var context = new TestDBContext())
        {
            foreach (var p in context.Person)
            {
                Person p2 = p; // to avoid capturing the loop variable
                ThreadPool.QueueUserWorkItem(
                    arg =>
                    {
                        Console.WriteLine("{0} lives in {1}.", p2.Name, p2.Address.City);
                    });
            }
        }
    }

该TestSingleThread …

我正在尝试实现泛型方法,该方法用于将Tuple<Descendant>类型的对象转换为类型的对象Tuple<Ancestor>.我遇到了一个似乎是C#语言限制的问题.

using System;

namespace Samples
{
    public static class TupleExtensions
    {
        public static Tuple<SuperOfT1> ToSuper<T1, SuperOfT1>(this Tuple<T1> target)
            where T1 : SuperOfT1
        {
            return new Tuple<SuperOfT1>(target.Item1);
        }
    }

    public interface Interface { }

    public class Class : Interface { }

    static class Program
    {
        static void Main()
        {
            var tupleWithClass = new Tuple<Class>(new Class());

            // Next instruction lead the compilation to error. :( The compiler doesn't try to infer types if at least one of generic …

我怀疑答案是否定的,但无论如何我都会问...

TL; DR

我知道我可以使用[ExcludeFromCodeCoverage]属性从覆盖率分析中排除一个类或方法,但有没有办法只排除方法的一部分？

具体例子

我有一个懒惰地生成一系列int.MaxValue元素的方法:

private static IEnumerable<TElement> GenerateIterator<TElement>(Func<int, TElement> generator)
{
    for (int i = 0; i < int.MaxValue; i++)
    {
        yield return generator(i);
    }
}

在实践中,它永远不会被完全枚举,因此永远不会达到方法的结束.因此,DotCover认为该方法的20%未被覆盖,并且它将右大括号突出显示为未覆盖(对应return false于生成的MoveNext方法).

我可以编写一个消耗整个序列的测试,但是运行需要很长时间,特别是启用了覆盖范围.

所以我想找一种告诉DotCover的方法,不需要覆盖最后一条指令.

注意:我知道我并不需要单元测试所涵盖的所有代码; 某些代码片段不能或不需要进行测试,我通常会排除那些具有该[ExcludeFromCodeCoverage]属性的代码.但我喜欢100%报告我测试的代码的覆盖率,因为它可以更容易地发现未经测试的代码部分.当你知道没有更多东西需要测试时,有80%覆盖率的方法是非常烦人的...