[C#] LINQ: Impossibile applicare inferenza di tipo

[Il Totem]

Ho il seguente codice:

var n = from e in vertex.OutgoingEdgesList
        select e.End;

vertex è di tipo ColoredGraph<V, Object>.Vertex
e è di tipo ColoredGraph<V, Object>.Edge
vertex.OutgoingEdgesList è di tipo List<ColoredGraph<V, Object>.Edge>
Tutti i tipi vengono riconosciuti correttamente dall'engine LINQ. Tuttavia appare questo errore:

The type of the expression in the select clause is incorrect. Type inference failed in the call to 'Select'.

Anche scrivendo:

var n = from e in vertex.OutgoingEdgesList select 1;

dove il tipo è chiaramente Int32, mi dà lo stesso errore.

E' assurdo che pur riuscendo a inferire il tipo dell'oggetto selezionato non possa inferiore il tipo corrispondente alla sua collezione, che dovrebbe essere IEnumerable<ColoredGraph<V, Object>.Vertex>.

[U235]

Originariamente inviato da Il Totem
Ho il seguente codice:

var n = from e in vertex.OutgoingEdgesList
        select e.End;

vertex è di tipo ColoredGraph<V, Object>.Vertex
e è di tipo ColoredGraph<V, Object>.Edge
vertex.OutgoingEdgesList è di tipo List<ColoredGraph<V, Object>.Edge>
Tutti i tipi vengono riconosciuti correttamente dall'engine LINQ. Tuttavia appare questo errore:

Anche scrivendo:

var n = from e in vertex.OutgoingEdgesList select 1;

dove il tipo è chiaramente Int32, mi dà lo stesso errore.

E' assurdo che pur riuscendo a inferire il tipo dell'oggetto selezionato non possa inferiore il tipo corrispondente alla sua collezione, che dovrebbe essere IEnumerable<ColoredGraph<V, Object>.Vertex>.

Ciao Il Totem, tu devi essere in famoso Totem della guida vb! Ne ho sentito parlare molto bene

riguardo al codice, così su due piedi da quello che si vede non sembrerebbe dare problemi, ma chiaramente senza vedere il resto del codice , sarebbe molto interessante poterlo vedere per capire il perchè di questo strano comportamento, magari se vuoi postarlo... stai usando DirectX?

ciao.

[Il Totem]

Sì, sono lo stesso Totem, l'unico e il solo
Sto cercando di scrivere una libreria per operare sui grafi in .NET. Il codice integrale aggiornato all'ultima versione beta è disponibile qui. Dovrebbe essere leggermente diverso dalla versione attuale del codice, ma la tipizzazione è la stessa.

[U235]

Ciao, la ColoredGraph non l'ho trovata, immagino che erediti dalla Graph, ma purtroppo, buttandola giù così, giusto per vedere se compilava, non non sono riuscito riprodurre il problema , puoi postare anche la ColoredGraph? magari anche il pezzo di codice come lo stavi implementando.

Ciao

[Il Totem]

Già, è vero, ho cambiato il nome alla classe. Quella che prima si chiamava Graph ora si chiama ColoredGraph. Ho risolto semplicemente facendo a meno di linq, ma non mi spiego ancora perché l'inferenza di tipo non abbia funzionato.

[U235]

Originariamente inviato da Il Totem
Già, è vero, ho cambiato il nome alla classe. Quella che prima si chiamava Graph ora si chiama ColoredGraph. Ho risolto semplicemente facendo a meno di linq, ma non mi spiego ancora perché l'inferenza di tipo non abbia funzionato.

l'omino dispettoso della Microsoft

Lo posso tenere il progetto ? ovviamente solo ed esclusivamente per me e a scopo di curiosità, prometto nessun altro uso, vorrei solo darli un'occhiata meglio

ciao

[Il Totem]

Il progetto è open-source, quindi non c'è motivo per cui tu non possa tenerlo. Non sarà molto performante, ma è flessibile.

[Il Totem]

Nonostante me la sia cavato per quella volta, ora LINQ mi serve sul serio per effettuare alcune query con tipi anonimi, ma mi restituisce lo stesso errore. Il codice è lo stesso e qualsiasi oggetto io usi dopo la clausola select, l'errore dice sempre che è di un tipo non corretto.

var data = from vertex in graph.Vertices
         select new { name = "ciao" };

Se provo a usare graph.Vertices.AsEnumerable(), mi dice che il metodo AsEnumerable non esiste, pur avendomelo appena suggerito con l'intellisense. Sto impazzendo... deve esserci qualche tranello di LINQ nascosto da qualche parte che compromette il codice, ma non riesco a trovarlo.

[alka]

Originariamente inviato da Il Totem
Nonostante me la sia cavato per quella volta, ora LINQ mi serve sul serio per effettuare alcune query con tipi anonimi, ma mi restituisce lo stesso errore. Il codice è lo stesso e qualsiasi oggetto io usi dopo la clausola select, l'errore dice sempre che è di un tipo non corretto.

Riusciresti a riprodurre la stessa condizione in un esempio di codice scritto da te?
Così forse è più comodo da analizzare.

Hai cercato in giro possibili indicazioni per problemi analoghi?

[Il Totem]

Ho estrapolato il minimo indispensabile per riprodurre l'errore:

namespace Proof
{
    public class ColoredGraph<V, E>
        where V : IEquatable<V>
        where E : IEquatable<E>
    {
        public class Vertex : IEquatable<Vertex>
        {
            public Int32 Index { get; internal set; }

            public V Data { get; set; }

            internal List<Edge> OutgoingEdgesList;
            internal List<Edge> IncomingEdgesList;

            public ReadOnlyCollection<Edge> OutgoingEdges { get; private set; }
            public ReadOnlyCollection<Edge> IncomingEdges { get; private set; }
            public IEnumerable<Vertex> Children
            {
                get
                {
                    foreach (Edge edge in this.OutgoingEdges)
                        yield return edge.End;
                }
            }

            internal Vertex()
            {
                this.OutgoingEdgesList = new List<Edge>();
                this.IncomingEdgesList = new List<Edge>();
                this.OutgoingEdges = new ReadOnlyCollection<Edge>(this.OutgoingEdgesList);
                this.IncomingEdges = new ReadOnlyCollection<Edge>(this.IncomingEdgesList);
            }

            public override string ToString()
            {
                return '{' + this.Data.ToString() + ", " + this.Index + '}';
            }

            public bool Equals(Vertex other)
            {
                if (other == null)
                    return false;
                return (this.Index == other.Index) && this.Data.Equals(other.Data);
            }
        }

        public class Edge : IEquatable<Edge>
        {
            public Vertex Start { get; set; }
            public Vertex End { get; set; }
            public E Data { get; set; }

            internal Edge() { }

            public override string ToString()
            {
                return String.Format("{0} : {1} -> {2}", this.Data.ToString(), this.Start.ToString(), this.End.ToString());
            }

            public bool Equals(Edge other)
            {
                if (other == null)
                    return false;
                return (this.Start == other.Start) && (this.End == other.End) && this.Data.Equals(other.Data);
            }

            public Boolean IsLoop()
            {
                return this.Start.Equals(this.End);
            }
        }
        
        protected List<Vertex> vertices;

        public ReadOnlyCollection<Vertex> Vertices { get; protected set; }

        // ...
    }

    public class ColoredTree<V, E> : ColoredGraph<V, E>
        where V : IEquatable<V>
        where E : IEquatable<E>
    {
        protected Vertex root;

        public Vertex Root
        {
            get { return root; }
            set
            {
                if (value.IncomingEdges.Count > 0)
                    throw new ArgumentException("The root vertex should not have any incoming edges.");
                root = value;
            }
        }

        public ColoredTree() : base() { }

        public Int32 GetHeight()
        {
            if (this.Root == null)
                throw new InvalidOperationException("Cannot calculate the height of an unrooted tree.");
            return this.GetHeight(this.Root);
        }

        private Int32 GetHeight(Vertex vertex)
        {
            if (vertex.OutgoingEdges.Count == 0)
                return 0;
            return 1 + vertex.OutgoingEdges.Select(edge => this.GetHeight(edge.End)).Max();
        }

        public Boolean IsIsomorphicTo<H, K>(ColoredTree<H, K> tree)
        {
            Int32 h = Math.Max(this.GetHeight(), tree.GetHeight());
        }

        private static Int32 GetRootLabel<H, K>(ColoredTree<H, K> tree)
        {
            List<Vertex>[] levels = new List<Vertex>[tree.GetHeight() + 1];

            for (Int32 i = 0; i < levels.Length; i++)
                levels[i] = new List<Vertex>();

            levels[0].Add(tree.Root);
            for (Int32 i = 1; i < levels.Length; i++)
                levels[i].AddRange(levels[i - 1].SelectMany(vertex => vertex.Children));

            var data = from vertex in tree.Vertices
                       select new { Vertex = vertex, Label = 0, OrderedLabels = new List<Int32>(), OrderedChildren = new List<Vertex>() };
        }
    }
}

Sto scrivendo un'implementazione dell'algoritmo standard per verificare se due alberi sono isomorfici. Mi sono bloccato nella dichiarazione di data, perché viene riportato l'errore sopracitato evidenziando la clausola select.

Ho già cercato tutti i possibili risultati su google. La maggior parte sono dovuti a un uso scorretto del selettore equals nella clausola join, quindi li ho scartati. I rimanenti risultati sono di scarsa rilevanza. Il primo è una descrizione generica dell'errore (da msdn). Il secondo e il quinto sono causati dal tentativo di restituire una funzione lambda. Il terzo viene da experts-exchange, che non è un sito molto affidabile. Il quarto è solo un esempio stupido. Il quinto punta a questa stessa discussione. I successivi sono risultati di scarsa rilevanza in quanto non riportano l'errore ma solo alcune parole chiave della ricerca. Non c'è assolutamente niente...