繁体   English   中英

“不希望使用RoleProxy类型。 使用XmlInclude或SoapInclude属性可以指定静态未知的类型。” NHibernate

[英]“The type RoleProxy was not expected. Use the XmlInclude or SoapInclude attribute to specify types that are not known statically.” NHibernate

因此,如标题所述:我收到一条错误消息,其中指出:“ System.InvalidOperationException:生成XML文档时出错。---> System.InvalidOperationException:不需要RoleProxy类型。请使用XmlInclude或SoapInclude属性指定静态未知的类型。”

我试图以Web服务中XML的形式返回数据库中的用户列表(密码专用)。

这是一些代码:

MS SQL Server数据库:

用户表:

CREATE TABLE [dbo].[Users] (
    [Id]       NVARCHAR (50) NOT NULL,
    [Username] NVARCHAR (50) NULL,
    [Password] NVARCHAR (50) NOT NULL,
    [Role]     NVARCHAR (50) NOT NULL,
    CONSTRAINT [PK_Users] PRIMARY KEY CLUSTERED ([Id] ASC),
    CONSTRAINT [FK_Users_Role] FOREIGN KEY ([Role]) REFERENCES [dbo].[Role] ([Id])
);

角色表:

CREATE TABLE [dbo].[Role] (
    [Id]   NVARCHAR (50) NOT NULL,
    [Name] NVARCHAR (50) NULL,
    CONSTRAINT [PK_Role] PRIMARY KEY CLUSTERED ([Id] ASC)
);

WebService.cs

using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Web.Services;
using NHibernate;
using Models;
using NHibernate.Mapping;

[WebService(Namespace = "http://LambdAlarm.com/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

public class LambdAlarmWebService : WebService
{
    [WebMethod]
    public List<Users> GetUser()
    {
        var factory = SessionFactory.Instance;
        var session = factory.OpenSession();
        var result = session.QueryOver<Users>().List<Users>();

        return result.ToList(); //Where I suspect the error occurs.
    }
}

Users.cs(模型)

namespace Models
{
    public class Users : EntityBase
    {
        public virtual string Username { get; set; }
        public virtual string Password { get; set; }
        public virtual Role Role { get; set; }
    }
}

Role.cs:

namespace Models
{
    public class Role : EntityBase
    {
        public virtual string Name { get; set; }
    }
}

EntityBase :(在所有模型中都继承有属性guid的类)

using System;

namespace Models
{
    public class EntityBase
    {
        public virtual Guid Id { get; set; }
    }
}

用户地图:

using FluentNHibernate.Mapping;
using Models;

namespace NHibernate.Mapping
{
    public class UserMap : ClassMap<Users>
    {
        public UserMap()
        {
            Table("Users");
            Id(x => x.Id).GeneratedBy.GuidComb();
            LazyLoad();
            References(x => x.Role).Column("Role");
            Map(x => x.Username).Column("Username");
            Map(x => x.Password).Column("Password").Not.Nullable();
        }
    }
}

角色图:

using FluentNHibernate.Mapping;
using Models;

namespace NHibernate.Mapping
{
    public class RoleMap : ClassMap<Role>
    {
        public RoleMap()
        {
            Table("Role");
            Id(x => x.Id).GeneratedBy.GuidComb();
            LazyLoad();
            Map(x => x.Name).Column("Name");
        }
    }
}

SessionFactory:

using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using Models;
using NHibernate.Conventions;

namespace NHibernate
{
    public static class SessionFactory
    {
        private static ISessionFactory _sessionFactory;

        public static ISessionFactory Instance
        {
            get
            {
                if (_sessionFactory == null)
                {
                    _sessionFactory = CreateSessionFactory();
                }

                return _sessionFactory;
            }
        }

        private static ISessionFactory CreateSessionFactory()
        {
            return Fluently.Configure()
                        .Database(MsSqlConfiguration.MsSql2012
                            .ConnectionString(c => c.FromConnectionStringWithKey("DatabaseConnectionString")))
                        .Mappings(m =>
                        {
                            m.FluentMappings.Conventions.AddFromAssemblyOf<CustomForeignKeyConvention>();
                            m.FluentMappings.AddFromAssemblyOf<EntityBase>();
                        })
                        .BuildSessionFactory();
        }
    }
}

约定:

using FluentNHibernate;
using FluentNHibernate.Conventions;

namespace NHibernate.Conventions
{
    public class CustomForeignKeyConvention : ForeignKeyConvention
    {
        protected override string GetKeyName(Member property, System.Type type)
        {
            if (property == null)
            {
                return type.Name;
            }

            return property.Name;
        }
    }
}

有人知道是什么问题吗? 帮助将不胜感激!

您没有告诉NHibernate您需要什么,因此它将延迟加载所有引用对象。 但是,这将产生代理。 也将阻止SELECT N + 1的最简单解决方案是急于加载角色。 还摆脱了结果列表的冗余复制。

[WebMethod]
public List<Users> GetUser()
{
    var factory = SessionFactory.Instance;
    using (var session = factory.OpenSession())
    {
        return session.QueryOver<Users>().Fetch(u => u.Role).List();
    }
}

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM