Exclude-Eigenschaft von WebApi OData (EF) Reaktion in c#

Ist es vielleicht ein wenig spät, aber eine elegante Lösung wäre das hinzufügen eines benutzerdefinierten QueryableSelectAttribute und dann einfach die Liste der Felder, die Sie auswählen möchten, die auf der Aufschlag-Seite. In deinem Fall wird es so Aussehen:

public class QueryableSelectAttribute : ActionFilterAttribute
{
    private const string ODataSelectOption = "$select=";
    private string selectValue;

    public QueryableSelectAttribute(string select)
    {
        this.selectValue = select;
    }

    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        base.OnActionExecuting(actionContext);

        var request = actionContext.Request;
        var query = request.RequestUri.Query.Substring(1);
        var parts = query.Split('&').ToList();

        for (int i = 0; i < parts.Count; i++)
        {
            string segment = parts[i];
            if (segment.StartsWith(ODataSelectOption, StringComparison.Ordinal))
            {
                parts.Remove(segment);
                break;
            }
        }

        parts.Add(ODataSelectOption + this.selectValue);

        var modifiedRequestUri = new UriBuilder(request.RequestUri);
        modifiedRequestUri.Query = string.Join("&", parts.Where(p => p.Length > 0));
        request.RequestUri = modifiedRequestUri.Uri;

        base.OnActionExecuting(actionContext);
    }
}

Und in der Steuerung fügen Sie einfach das Attribut mit den gewünschten Eigenschaften:

[EnableQuery]
[QueryableSelect("Name,LastName,Email")]
public IQueryable<User> GetUsers()
{
    return db.Users;
}

... Und das ist es!

Natürlich das gleiche Prinzip kann auch angewendet werden für eine benutzerdefinierte QueryableExpandAttribute.

Wie kann ich ausschließen das Passwort von Ergebnisse, aber halten im controller zu machen Linq-Abfragen?

Ignorieren. Von Sicherheitsempfehlungen für ASP.NET Web-API OData-2:

Gibt es zwei Möglichkeiten, um ausschließlich eine Eigenschaft von EDM. Sie können die
[IgnoreDataMember] - Attribut auf dem Grundstück in der model-Klasse:

public class Employee
{
    public string Name { get; set; }
    public string Title { get; set; }
    [IgnoreDataMember]
    public decimal Salary { get; set; } //Not visible in the EDM
}

Können Sie auch entfernen Sie die Eigenschaft aus der EDM programmatisch:

var employees = modelBuilder.EntitySet<Employee>("Employees");
employees.EntityType.Ignore(emp => emp.Salary);

Sie bereits versucht, dies?

Aktualisieren Sie einfach die Eigenschaft.

[EnableQuery]
public async Task<IQueryable<User>> GetUsers()
{
    var users = db.User;

    await users.ForEachAsync(q => q.Password = null);

    return users;
}

Machte ich ein Handwerk und vorübergehende Lösung für dieses problem (ist nicht die beste Lösung, da UserInfo ist nicht eine Entität geben, und nicht $select und $expand).
Ich erstellte ein neues Modell namens UserInfo nur mit den Eigenschaften die ich brauche (abgesehen von der Benutzer):

public class UserInfo
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

Dann änderte ich die Methode im controller:

//GET: odata/Users
[EnableQuery]
public IQueryable<UserInfo> GetUsers()
{
    List<UserInfo> lstUserInfo = new List<UserInfo>();

    foreach(User usr in db.Users)
    {
        UserInfo userInfo = new UserInfo();
        userInfo.Id = usr.Id;
        userInfo.Name = usr.Name;
        userInfo.Email = usr.Email;

        lstUserInfo.Add(userInfo);
    }

    return lstUserInfo.AsQueryable();
}

Nichts anderes für mich gearbeitet, so ist hier eine elegante Lösung.

Verwenden Sie die HideSensitiveProperties() Erweiterung Methode in Ihrer TableController wie diese.

    //GET tables/User
    public IQueryable<User> GetAllUsers()
    {
        return Query().HideSensitiveProperties();
    }

    //GET tables/User/48D68C86-6EA6-4C25-AA33-223FC9A27959
    public SingleResult<User> GetUser(string id)
    {
        return Lookup(id).HideSensitiveProperties();
    }

    //PATCH tables/User/48D68C86-6EA6-4C25-AA33-223FC9A27959
    public Task<User> PatchUser(string id, Delta<User> patch)
    {
        return UpdateAsync(id, patch).HideSensitivePropertiesForItem();
    }

    //POST tables/User
    public async Task<IHttpActionResult> PostUser(User item)
    {
        User current = await InsertAsync(item);
        current.HideSensitivePropertiesForItem();
        return CreatedAtRoute("Tables", new { id = current.Id }, current);
    }

    //DELETE tables/User/48D68C86-6EA6-4C25-AA33-223FC9A27959
    public Task DeleteUser(string id)
    {
        return DeleteAsync(id);
    }

Aber dies wird nicht entfernen Sie die Eigenschaft name von der Reaktion, aber es wird seinen Wert zu null.

public static class HideSensitivePropertiesExtensions
{
    public static async Task<TData> HideSensitivePropertiesForItem<TData>(this Task<TData> task)
        where TData : ModelBase
    {
        return (await task).HideSensitivePropertiesForItem();
    }

    public static TData HideSensitivePropertiesForItem<TData>(this TData item)
        where TData : ModelBase
    {
        item.Password = null;
        return item;
    }

    public static SingleResult<TData> HideSensitiveProperties<TData>(this SingleResult<TData> singleResult)
        where TData : ModelBase
    {
        return new SingleResult<TData>(singleResult.Queryable.HideSensitiveProperties());
    }

    public static IQueryable<TData> HideSensitiveProperties<TData>(this IQueryable<TData> query)
        where TData : ModelBase
    {
        return query.ToList().HideSensitiveProperties().AsQueryable();
    }

    public static IEnumerable<TData> HideSensitiveProperties<TData>(this IEnumerable<TData> query)
        where TData : ModelBase
    {
        foreach (var item in query)
            yield return item.HideSensitivePropertiesForItem();
    }
}

Hier ModelBase ist die Basisklasse für alle DTOs.

verwenden Automapper

[EnableQuery]
public IQueryable<User> GetUsers()
{
    //Leave password empty
    Mapper.CreateMap<User, User>().ForMember(x => x.Password, opt => opt.Ignore());

    return db.Users.ToList().Select(u=>Mapper.Map<User>(u)).AsQueryable();      
}