无论如何,我有一个像这样的域对象：

public class User
{
   public string Name { get; set; }
   public FacebookUser FacebookUser { get; set; }
}

像这样的viewmodel：

public class Userviewmodel
{
   public string Name { get; set; }
   public long FacebookUniqueId { get; set; }
}

这是我在AutoMapper配置中的内容：

Mapper.CreateMap<User,Userviewmodel>()
   .ForMember(dest => dest.FacebookUniqueId,opt => opt.MapFrom(src => src.FacebookUser.FacebookUniqueId))

但是当FacebookUser对象为null时,它会引发异常,这是预期的.

我如何告诉AutoMapper：

Map Userviewmodel.FacebookUniqueId to User.FacebookUser.FacebookUniqueId,except for when it’s null,then use 0.

有任何想法吗？

opt => opt.MapFrom(src => src.FacebookUser == null ? 0 : src.FacebookUser.FacebookUniqueId)

如果我刚刚检查过第一个想法是否有效,那就认为MapFrom方法只采用了一个指向属性的表达式来解决它…

这是查询代码：

const string storedProc = "dbo.GetStopsForRouteID";

        var stops = conn.Query<RouteStop,MapLocation,RouteStop>(
           storedProc,(stop,loc) =>
        {
            stop.Location = loc;
            return stop;
        },new { RouteID = routeId },commandType: CommandType.StoredProcedure);

在第498行的Dapper.cs中：

var deserializer2 = (Func<IDataReader,TSecond>)info.OtherDeserializers[0];

info.OtherDeserializers为null,导致NullReferenceException.

这是存储过程的内容：

SELECT 
    RouteStops.StopID,RouteStops.Name,RouteStops.Description,RouteStops.IsInbound,RouteStops.Location.Lat as Latitude,RouteStops.Location.Long as Longitude
FROM dbo.Routes

INNER JOIN dbo.StopsOnRoute ON
Routes.RouteID = StopsOnRoute.RouteID

INNER JOIN dbo.RouteStops ON
StopsOnRoute.StopID = RouteStops.StopID

WHERE Routes.RouteID = @RouteID
ORDER BY StopsOnRoute.SequenceNumber

我已经对dapper代码进行了广泛的研究,但除了TFirst的deserialiser不是null之外我找不到任何看似不合适的东西,但是TSecond是.当它创建TSecond的反序列化器并将其保留为null时会出现问题吗？

以下是类型：

public class MapLocation
{
    public double Latitude { get; set; }
    public double Longitude { get; set; }
}

public class RouteStop {
    public int StopID { get; set; }

    public string Name { get; set; }
    public string Description { get; set; }
    public bool IsInbound { get; set; }

    public MapLocation Location { get; set; }
}

splitOn: "Latitude"

没有它,只要dapper可以看到没有第二个结果部分(默认情况下它在Id上分裂).

如果我使用enum Foo {A,P}之类的单个字符名称的枚举,我很确定Dapper会正确映射它们但我不希望这样,我想要带有描述性标签的枚举如下：

enum Foo {
    [StringValue("A")]
    Active,[StringValue("P")]
    Proposed
}

在上面的例子中,StringValueAttribute是一个自定义属性,我可以使用反射将“A”转换为Foo.Active,这很好 – 除了我需要Dapper为我执行转换逻辑.我写了一个自定义类型处理程序来执行此操作

public class EnumTypeHandler<T> : sqlMapper.TypeHandler<T>
{
    public override T Parse(object value)
    {
        if (value == null || value is dbnull) { return default(T); }
        return EnumHelper.FromStringValue<T>(value.ToString());
    }

    public override void SetValue(IDbDataParameter parameter,T value)
    {
        parameter.DbType = DbType.String;
        parameter.Value = EnumHelper.GetStringValue(value as Enum);
    }
}

//Usage:
sqlMapper.AddTypeHandler(typeof(Foo),(sqlMapper.ITypeHandler)Activator.CreateInstance(typeof(EnumTypeHandler<>).MakeGenericType(typeof(Foo)));

使用sqlMapper.AddTypeHandler()注册似乎工作正常,但是当我的DbConnection.Query()代码运行时,我收到一条错误,指出无法转换值’A’ – 从Enum.Parse抛出错误,提示Dapper实际上并没有调用我的类型处理程序,尽管它已被注册.有没有人知道这方面的方法？

从AutoMapper wiki我学会了创建一个简单的映射

Mapper.CreateMap<CalendarEvent,CalendarEventForm>().ForMember(dest => dest.Title,opt => opt.MapFrom(src => src.Title));
    Mapper.CreateMap<CalendarEvent,CalendarEventForm>().ForMember(dest => dest.EventDate,opt => opt.MapFrom(src => src.EventDate.Date));
    Mapper.CreateMap<CalendarEvent,CalendarEventForm>().ForMember(dest => dest.EventHour,opt => opt.MapFrom(src => src.EventDate.Hour));
    Mapper.CreateMap<CalendarEvent,CalendarEventForm>().ForMember(dest => dest.EventMinute,opt => opt.MapFrom(src => src.EventDate.Minute));

像两个班

public class CalendarEvent
{
    public DateTime EventDate;
    public string Title;
}

public class CalendarEventForm
{
    public DateTime EventDate { get; set; }
    public int EventHour { get; set; }
    public int EventMinute { get; set; }
    public string Title { get; set; }
}

我现在想知道是否有可能在外部定义映射,例如在XML文件中

<ObjectMapping>
<mapping>
    <src>Title</src>
    <dest>Tile</dest>
</mapping>
<mapping>
    <src>EventDate.Date</src>
    <dest>EventDate</dest>
</mapping>
<mapping>
    <src>EventDate.Hour</src>
    <dest>EventHour</dest>
</mapping>
<mapping>
    <src>EventDate.Minute</src>
    <dest>EventMinute</dest>
</mapping>

并通过这种影响创建地图(XML不是一个要求,也可以是其他一切).
为简单起见,说类型没有问题,所以src和dest应该是相同的,否则可以失败.这背后的想法是在应该映射的内容和应该映射的位置上非常灵活.我正在考虑根据其名称获取属性值的反射,但这似乎不起作用.
我也不确定这是否有意义,或者我是否遗漏了重要的东西,所以我们非常感谢帮助和想法.

我使用了here和here中的代码,并添加了类PropertyMapping来存储从XML读取的映射,还添加类Foo和Bar来创建嵌套数据结构,以便复制到.

无论如何这里是代码,也许它可以帮助某人一些时间：

主要：

public class Program
{
    public static void Main(string[] args)
    {
        // Model
        var calendarEvent = new CalendarEvent
        {
            EventDate = new DateTime(2008,12,15,20,30,0),Title = "Company Holiday Party"
        };

        MyObjectMapper mTut = new MyObjectMapper(@"SampleMappings.xml");

        Console.WriteLine(string.Format("Result MyMapper: {0}",Program.CompareObjects(calendarEvent,mTut.TestMyObjectMapperProjection(calendarEvent))));

        Console.ReadLine();
    }

    public static bool CompareObjects(CalendarEvent calendarEvent,CalendarEventForm form)
    {
        return calendarEvent.EventDate.Date.Equals(form.EventDate) &&
               calendarEvent.EventDate.Hour.Equals(form.EventHour) &&
               calendarEvent.EventDate.Minute.Equals(form.EventMinute) &&
               calendarEvent.Title.Equals(form.Title);
    }
}

Mapper实现：

public class MyObjectMapper
{
    private List<PropertyMapping> myMappings = new List<PropertyMapping>();

    public MyObjectMapper(string xmlFile)
    {
        this.myMappings = GenerateMappingObjectsFromXml(xmlFile);
    }

    /*
     * Actual mapping; iterate over internal mappings and copy each source value to destination value (types have to be the same)
     */ 
    public CalendarEventForm TestMyObjectMapperProjection(CalendarEvent calendarEvent)
    {
        CalendarEventForm calendarEventForm = new CalendarEventForm();

        foreach (PropertyMapping propertyMapping in myMappings)
        {
            object originalValue = GetPropValue(calendarEvent,propertyMapping.FromPropertyName);

            SetPropValue(propertyMapping.ToPropertyName,calendarEventForm,originalValue);
        }

        return calendarEventForm;
    }
    /*
     * Get the property value from the source object
     */ 
    private object GetPropValue(object obj,String compoundProperty)
    {
        foreach (String part in compoundProperty.Split('.'))
        {
            if (obj == null) { return null; }

            Type type = obj.GetType();
            PropertyInfo info = type.GetProperty(part);
            if (info == null) { return null; }

            obj = info.GetValue(obj,null);
        }
        return obj;
    }
    /*
     * Set property in the destination object,create new empty objects if needed in case of nested structure
     */ 
    public void SetPropValue(string compoundProperty,object target,object value)
    {
        string[] bits = compoundProperty.Split('.');
        for (int i = 0; i < bits.Length - 1; i++)
        {
            PropertyInfo propertyToGet = target.GetType().GetProperty(bits[i]);

            propertyToGet.SetValue(target,Activator.CreateInstance(propertyToGet.PropertyType));

            target = propertyToGet.GetValue(target,null);               
        }
        PropertyInfo propertyToSet = target.GetType().GetProperty(bits.Last());
        propertyToSet.SetValue(target,value,null);
    }              

    /*
     * Read XML file from the provided file path an create internal mapping objects
     */ 
    private List<PropertyMapping> GenerateMappingObjectsFromXml(string xmlFile)
    {
        XElement definedMappings = XElement.Load(xmlFile);
        List<PropertyMapping> mappings = new List<PropertyMapping>();

        foreach (XElement singleMappingElement in definedMappings.Elements("mapping"))
        {
            mappings.Add(new PropertyMapping(singleMappingElement.Element("src").Value,singleMappingElement.Element("dest").Value));
        }

        return mappings;
    } 
}

我的模型类：

public class CalendarEvent
{
    public DateTime EventDate { get; set; }
    public string Title { get; set; }
}

public class CalendarEventForm
{
    public DateTime EventDate { get; set; }
    public int EventHour { get; set; }
    public int EventMinute { get; set; }
    public string Title { get; set; }
    public Foo Foo { get; set; }
}

public class Foo
{
    public Bar Bar { get; set; }

}

public class Bar
{
    public DateTime InternalDate { get; set; }

}

内部映射表示：

public class PropertyMapping
{
    public string FromPropertyName;
    public string ToPropertyName;

    public PropertyMapping(string fromPropertyName,string toPropertyName)
    {
        this.FromPropertyName = fromPropertyName;
        this.ToPropertyName = toPropertyName;
    }
}

示例XML配置：

<?xml version="1.0" encoding="utf-8" ?>
    <ObjectMapping>
      <mapping>
        <src>Title</src>
        <dest>Title</dest>
       </mapping>
      <mapping>
        <src>EventDate.Date</src>
        <dest>EventDate</dest>
      </mapping>
      <mapping>
        <src>EventDate.Hour</src>
        <dest>EventHour</dest>
      </mapping>
      <mapping>
        <src>EventDate.Minute</src>
        <dest>EventMinute</dest>
      </mapping>
      <mapping>
        <src>EventDate</src>
        <dest>Foo.Bar.InternalDate</dest>
      </mapping>
     </ObjectMapping>

gpg --batch --no-tty --no-use-agent --symmetric --cipher-algo AES256 --passphrase "foobar" /path/to/file_to_be_encrypted

如果没有–no-use-agent选项,我会收到臭名昭着的错误消息

gpg-agent is not available in this session

我担心转移到gpg2因为,according to the documentation,gpg-agent总是需要的,而且–no-use-agent只是一个虚拟选项.我的gpg调用通过守护进程在后台发生,所以这是一个非代理方案(加上它是对称的,我根本不需要代理).

这个详细程度的文档很少,所以我正在寻找用户体验. gpg2是否更紧密地合并了代理,因此我不必担心它的可用性？

gpg2 --batch --yes --no-tty --no-use-agent --symmetric --cipher-algo AES256 --passphrase "foobar" /path/to/file_to_be_encrypted

>当你使用对称加密时(就像你一样),密码短语约束(即使设置为由gpg-agent强制执行)也不会被应用 – 它只会起作用.

假设gpg-agent是这样运行的(让mypasswords文件甚至包含与您的密码完全匹配的禁用模式)：

eval $(gpg-agent --daemon --enforce-passphrase-constraints --min-passphrase-len 8 --min-passphrase-nonalpha 4 --check-passphrase-pattern mypasswords)

然后你的命令仍然会成功.

简而言之：gpg-agent不会让它失败(除非因某些原因崩溃gpg – 如错误配置或丢失可执行文件,你无法解释).

编辑：我刚检查并在对称模式下gpg2将工作,即使gpg-agent配置错误或gpg-agent可执行文件丢失.

这是不相关的,但以防万一：我还验证了当你试图在gpg-agent缺失或配置错误时更改私钥密码时会发生什么：gpg2会报告一个警告,甚至不会要求新的密码,并继续工作.

资料来源：

> gpg-agent configuration manual
> gpg documentation

drwx------  2 jason jason  4096 Feb 11 21:10 ./
drwx------ 90 jason jason 45056 Feb 11 20:49 ../
-rw-------  1 jason jason  9398 Feb 11 20:49 gpg.conf
-rw-rw-r--  1 jason jason  2316 Feb 11 21:10 mypk
-rw-------  1 jason jason  1633 Feb 11 20:52 pubring.gpg
-rw-------  1 jason jason  1633 Feb 11 20:52 pubring.gpg~
-rw-------  1 jason jason   600 Feb 11 20:52 random_seed
-rw-------  1 jason jason  1794 Feb 11 20:52 secring.gpg
-rw-------  1 jason jason  1280 Feb 11 20:52 trustdb.gpg

我是否正确理解secring.gpg是我的私钥？这个文件受我的密码保护,对吧？将此文件保存在我的机器上可以吗？我应该把它移到更安全的地方(比如拇指驱动器)吗？

Am I correct to understand that secring.gpg is my private key?

来自男人gpg：

~/.gnupg/secring.gpg
       The secret keyring.  You should backup this file.

This file is protected by my passphrase,right?

如果你设置一个,是的.实际上文件本身并不受保护,但每个包含的密钥都可以(您的密钥环中可以有多个私钥).

Is it ok to just keep this file on my machine? Should I move it somewhere more secure (say a thumb drive)?

这取决于您的需求和对机器的信任.

>您是否有特殊的安全需求,共享您的机器或期望它被黑/被盗/ ……？最好把它放在外部设备上,然后每当使用gpg时将其引用–secret-keyring /path/to/secring.gpg或将其放入你的gpg.conf：secret-keyring /path/to/secring.gpg.
>您是否相信计算机的完整性,甚至可能加密了您的文件？你需要经常使用你的密钥吗？最好将文件保存在硬盘上,因为这样可以省去使用gpg的麻烦.

要将密钥放在单独的设备上,请考虑使用OpenPGP card.使用一个,您的密钥永远不会离开该卡(用于签名和解密),而是用于备份目的.绝对也会增加书呆子因素.

private void setDateInTopBar() {
        Date bodyPartDate = DataManager.instance().getSelectedBodyPart().getPublicationDate();
        SimpleDateFormat format = new SimpleDateFormat("dd/mm/yyyy");
        String formattedDate = format.format(bodyPartDate);
        TextView dateTxt = (TextView) findViewById(R.id.txtimageDate);
        dateTxt.setText(formattedDate);
    }

但我的月份是0,当日和年工作正常时,问题是什么？

SimpleDateFormat format = new SimpleDateFormat("dd/mm/yyyy");

附：

SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");

因为毫米参考分钟..检查http://developer.android.com/reference/java/text/SimpleDateFormat.html

public class ISO8601TLDateFormat extends SimpleDateFormat {

    private static String mISO8601T = "yyyy-MM-dd''T''HH:mm:ss.SSSZ";

    public ISO8601TLDateFormat() {
        super(mISO8601T);
    }

    public ISO8601TLDateFormat(Locale inLocale) {
        super(mISO8601T,inLocale);
    }
}

正如您所看到的,目的是生成或解释日期

2012-03-17T00：00：00.000 0100

这是Azure服务所期望的.但是,当我输入从DatePicker构造的Date对象时：

mDate = new Date(mDatePicker.getYear(),mDatePicker.getMonth(),mDatePicker.getDayOfMonth());

ISO8601TLDateFormat的输出是

3912-03-17T00：00：00.000 0100

正如你所看到的,这一年比我更多,或者不是未来的任何人都需要.我已经仔细检查了Date对象到Azure Feed系统的整个过程,它报告的日期是2012年,这是我所期望的.为什么SimpleDateFormat会破坏？

public Date(int year,int month,int date)
Deprecated. As of JDK version 1.1,replaced by Calendar.set(year + 1900,month,date) or GregorianCalendar(year + 1900,date).
Allocates a Date object and initializes it so that it represents midnight,local time,at the beginning of the day specified by the year,and date arguments.
Parameters:
year - the year minus 1900.
month - the month between 0-11.
date - the day of the month between 1-31.

你需要记住,你构造的日期是0,1,是1900年1月1日.

每当我尝试调用webservice上的任何方法时，调用实际上会成功，但是当处理响应时客户端失败，并且我收到异常。

错误的细节如下，谢谢你们可以提供的任何帮助。

使用Web引用错误(旧式webservice客户端)

当作为Web引用使用该服务时，我得到一个InvalidOperationException用于我所做的任何调用，并显示以下消息：

Client found response content type of ''multipart/related; type="application/xop+xml"; boundary="uuid:170e63fa-183c-4b18-9364-c62ca545a6e0"; start="<root.message@cxf.apache.org>"; start-info="text/xml"'',but expected ''text/xml''.
The request Failed with the error message:
--

--uuid:170e63fa-183c-4b18-9364-c62ca545a6e0
Content-Type: application/xop+xml; charset=UTF-8; type="text/xml";
Content-transfer-encoding: binary
Content-ID: <root.message@cxf.apache.org>

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <ns2:openApiConnectionResponse xmlns:ns2="http://api.service.apibatchmember.emailvision.com/" xmlns:ns3="http://exceptions.service.apibatchmember.emailvision.com/">
      <return>DpKTe-9swUeOsxhHH9t-uLPeLyg-aa2xk3-aKe9oJ5S9Yymrnuf1FxYnzpaFojsQSkSCbJsZmrZ_d3v2-7Hj</return>
    </ns2:openApiConnectionResponse>
  </soap:Body>
</soap:Envelope>
--uuid:170e63fa-183c-4b18-9364-c62ca545a6e0--
--.

如你所见，响应肥皂包看起来是有效的(这是一个有效的响应，并且调用成功)，但客户端似乎对内容类型有问题并产生异常。

使用服务引用错误(WCF客户端)

当我将服务作为服务参考使用时，我会收到一个ProtocolException用于我所做的任何调用，并显示以下消息：

The content type multipart/related; type="application/xop+xml"; boundary="uuid:af66440a-012e-4444-8814-895c843de5ec"; start="<root.message@cxf.apache.org>"; start-info="text/xml" of the response message does not match the content type of the binding (text/xml; charset=utf-8). If using a custom encoder,be sure that the IsContentTypeSupported method is implemented properly. The first 648 bytes of the response were: ''
--uuid:af66440a-012e-4444-8814-895c843de5ec
Content-Type: application/xop+xml; charset=UTF-8; type="text/xml";
Content-transfer-encoding: binary
Content-ID: <root.message@cxf.apache.org>

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <ns2:openApiConnectionResponse xmlns:ns2="http://api.service.apibatchmember.emailvision.com/" xmlns:ns3="http://exceptions.service.apibatchmember.emailvision.com/">
      <return>Dqaqb-MJ9V_eplZ8fPh4tdHUbxM-ZtuZsDG6galAGZSfSzyxgtuuIxZc3aSsnhI4b0SCbJsZmrZ_d3v2-7G8</return>
    </ns2:openApiConnectionResponse>
  </soap:Body>
</soap:Envelope>
--uuid:af66440a-012e-4444-8814-895c843de5ec--''.

就像前面的例子一样;我们有一个有效的soap响应，并且调用成功，但客户端似乎对内容类型有问题，并产生了异常。

有没有我可以设置的选项，所以客户端没有响应类型的问题？我已经做了一些谷歌的搜索，但我发现没有什么帮助我到目前为止。

以下是所需配置设置的代码段：

<configuration>
  <system.serviceModel>
    <bindings>
      <basicHttpBinding>
        <binding messageEncoding="Mtom">          
        </binding>
      </basicHttpBinding>
    </bindings>
  </system.serviceModel>
</configuration>

编辑：如果您有与自定义绑定相同的问题，请参阅answer from @robmzd。

我仍然没有找到一个解决方案来消费它作为一个旧式的Web引用。