小编Dav*_*nde的帖子

我正在尝试这种代码优先的方法,但我现在发现System.Decimal类型的属性被映射到decimal(18,0)类型的sql列.

如何设置数据库列的精度？

有没有办法配置XmlSerializer,以便它不会在根元素中写入默认命名空间？

我得到的是这个:

<?xml ...>
<rootelement xmlns:xsi="..." xmlns:xsd="...">
</rootelement>

我想删除两个xmlns声明.

重复:如何在不获取xmlns ="..."的情况下将对象序列化为XML？

给出以下示例:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace SerializationTest
{
    [Serializable]
    class Foo : Dictionary<int, string>
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
            Foo foo = new Foo();
            foo[1] = "Left";
            foo[2] = "Right";

            BinaryFormatter formatter = new BinaryFormatter();
            MemoryStream stream = new MemoryStream();

            formatter.Serialize(stream, foo);
            stream.Seek(0, SeekOrigin.Begin);
            formatter.Deserialize(stream);
        }
    }
}

在最后一行中,抛出了SerializationException,因为格式化程序找不到Foo的构造函数.这是为什么？

我有这个WPF应用程序从REST Web服务获取数据并返回JSON数据.然后这个数据将转换为xml.稍后将此xml文件转换回JSON,以与来自调用相同功能的REST Web服务的新JSON数据进行比较.我该怎么做呢？

以下是我所做的一个示例:

HTTPGet req = new HTTPGet();
            req.Request("http://restservice//function");
            string str= req.ResponseBody;
            StringBuilder xmlTemplate = new StringBuilder("{\"?xml\":{\"@version\": \"1.0\",\"@standalone\": \"no\"},\"root\":REPLACE }");
            StringBuilder json = xmlTemplate.Replace(Constants.Constants.XMLREPLACEVAL, str); //this so that it will be same with the JObject from XML file
            JObject jObject1 = JObject.Parse(json.ToString());

            XmlDocument doc = new XmlDocument();
            string xml = File.ReadAllText("json.xml");
            doc.LoadXml(xml);
            string jsonText = JsonConvert.SerializeXmlNode(doc);
            JObject jObject2 = JObject.Parse(jsonText);

            if(jObject1.Equals(jObject2))
                //DO SOMETHING

给定具有以下接口的基类:

public class Base
{
    public virtual IEnumerable<string> GetListOfStuff()
    {
        yield return "First";
        yield return "Second";
        yield return "Third";
    }
}

我想创建一个覆盖该方法的派生类,并添加自己的东西,如下所示:

public class Derived : Base
{
    public override IEnumerable<string> GetListOfStuff()
    {
        foreach (string s in base.GetListOfStuff())
        {
            yield return s;
        }

        yield return "Fourth";
        yield return "Fifth";
    }
}

但是,我受到了警告,"无法验证通过迭代器中的基本关键字访问成员".

那么这个问题的解决方案是什么？

似乎无法确定解析依赖项的类型：

containerBuilder.Register(context =>
{
   // What is the type for which this component is resolved?
   var type = default(Type); // TBD
   return context.Resolve<ILoggerFactory>().CreateLogger(type);
});

此处的目标是创建 .NET Core 记录器，该记录器具有适用于它的类型的正确类别。

Autofac 文档中的示例描述了如何使用中间件组件实现这一点，我成功了。但似乎为每个注册添加一个管道会影响性能，而且我还没有发现一种方法来只将管道应用于依赖 ILogger 的组件的注册。

动机：显而易见的选择似乎是将依赖项更改为类型ILogger<T>，其中 T 是应用此依赖项的类型，如下所示：

public class Component
{
    public Component(ILogger<Component> logger)...
}

但是经验告诉我，很多开发者草草复制粘贴组件，忘记更改类型参数，导致日志混乱。在当前代码中，我们仍然使用 Common.Logging，我们的组件只需要一个非泛型 ILog：

public class Component
{
    public Component(ILog log)...
}

在我们之前的 DI 容器 Castle.Windsor 中，它会像这样简单：

public class LoggerSubDependencyResolver : ISubDependencyResolver
{
    public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
    {
        return …

给定具有多个值的排序向量,如以下示例所示:

std::vector<double> f;
f.pushback(10);
f.pushback(100);
f.pushback(1000);
f.pushback(10000);

我正在寻找最优雅的方法来检索任何双d紧邻它的两个值.例如,给定值"45",我希望返回"10"和"100".

我看着lower_bound和upper_bound,但他们没有做我想要的.你能帮我吗？

编辑:我已经决定发布我自己的anser,因为它有点是我在这个帖子中得到的所有有用答案的组合.我已经投了那些我认为最有帮助的答案.

感谢大家,

戴夫

假设我有以下(简单的简单)基类:

public class Simple
{
    public string Value { get; set; }
}

我现在想要做以下事情:

public class PathValue : Simple
{
    [XmlAttribute("path")]
    public string Value { get; set; }
}

public class ObjectValue : Simple
{
    [XmlAttribute("object")]
    public string Value { get; set; }
}

但实际上没有重新定义财产.我想将属性应用于基类的成员.这可能吗？

真正的问题是,在我从/到XML的序列化机制(它工作得非常出色),我发现很多类似的元素只有属性的名称不同(它们不一致,我不控制格式).现在我需要为每个这样的元素创建一个不同的类,而它们就像100%相同(除了属性).

我不认为这是可能的,但你可能永远不会知道.

更新:

我试过Marc的方法,但无济于事:

public class Document
{
    public PathValue Path;
    public ObjectValue Object;
}

class Program
{
    static void Main(string[] args)
    {
        var doc = new Document()
        {
            Path = new PathValue() { Value …

我目前正在评估AutoMapper是否对我们的项目有益.我正在使用ASP.NET Web API开发RESTful Web API,我必须返回的一个内容是包含链接的资源.考虑这个简化的示例,使用以下域对象:

public class Customer
{
    public string Name { get; set; }
}

我需要将它映射到一个资源对象,有点像DTO,但增加了属性以方便REST.这是我的资源对象可能是这样的:

public class CustomerResource
{
    public string Name { get; set; }
    public Dictionary<string, string> Links { get; set; }
}

Links属性需要包含相关资源的链接.现在,我可以使用以下方法构建它们:

public IEnumerable<CustomerResource> Get()
{
    Func<Customer, CustomerResource> map = customer => 
        new CustomerResource
        {
            Name = customer.Name,
            Links = new Dictionary<string, string>()
            {
                {"self", Url.Link("DefaultApi", new { controller = "Customers", name = customer.Name })}
            }
        }

    var customers = Repository.GetAll();
    return customers.Select(map); …

只是一个快速查询:我有一段代码将一个字符串与一长串值进行比较,例如

if(str == "string1" || str == "string2" || str == "string3" || str == "string4".
     DoSomething();

代码清晰度和可维护性的兴趣我把它改成了

public static string[] strValues = { "String1", "String2", "String3", "String4"};
...
if(strValues.Contains(str)
    DoSomething();

只发现代码执行时间从2.5秒到6.8秒(执行大约200,000次).
我当然明白了一个轻微的表现权衡,但300%？
无论如何,我可以不同地定义静态字符串以提高性能？
干杯.