Est-il une meilleure façon de répartir cette chaîne à l'aide de LINQ?

J'ai un peu de longitude\latitude coordonnées tassent dans une chaîne que j'aimerais divisé en longitude\latitude paires. Grâce à stackoverflow j'ai été en mesure de venir avec certains linq qui divisera en multidimensionnelle tableau de chaînes. Est-il possible de fractionner la chaîne directement dans un objet qui accepte la longitude la latitude vs un tableau de chaînes ensuite créer l'objet?

string segment = "51.54398, -0.27585;51.55175, -0.29631;51.56233, -0.30369;51.57035, -0.30856;51.58157, -0.31672;51.59233, -0.3354"

string[][] array = segment.Split(';').Select(s => s.Split(',')).ToArray();
foreach (string[] pair in array)
{
//create object here
}

Il est (presque?) jamais une bonne façon de découper une chaîne de caractères à l'aide de linq. Cela dit, le Système.Texte.RegularExpressions est ce que vous voulez
Qu'est-ce que -0.3354", "London:484" à la fin de votre chaîne?
À l'aide d'une expression régulière pour une telle tâche triviale est exagéré. Si vous savez que le format de votre entrée est constante et qu'il est facile à analyser par le fractionnement de vous doit être à l'aide de split, au lieu d'une regex.
Désolé, quelques données supplémentaires.
Pas un grand fan de RegualrExpressions mais j'apprécie la réponse.

OriginalL'auteur NullReference | 2012-04-09

c#linq

23

Vous sont proches. Quelque chose comme ce qui pourrait aider:
```
var pairSequence = segment.Split(';')
        .Select(s => s.Split(','))
        .Select(a => new { Lat = double.Parse(a[0]), Long = double.Parse(a[1]) });
```
Bien sûr, dépend du type que vous avez réellement besoin. Vous obtenez l'idée.
Merde. Était en train d'écrire quelque chose de presque identiques. Bravo.
Parfait, merci! Juste oublié le nouveau {} partie.

OriginalL'auteur Mehrdad Afshari

En supposant que vous avez un Coordinate classe avec un public Coordinate(double x, double y) constructeur, vous pouvez le faire:

Coordinate[] result = segment
    .Split(';')
    .Select(s => s.Split(','))
    .Select(a => new Coordinate(x: double.Parse(a[0], NumberStyles.Number),
                                y: double.Parse(a[1], NumberStyles.Number))
    .ToArray();

ou égale

var query = from item in segment.Split(';')
            let parts = item.Split(',')
            let x = double.Parse(parts[0], NumberStyles.Number)
            let y = double.Parse(parts[1], NumberStyles.Number)
            select new Coordinate(x, y);

Coordinate[] result = query.ToArray();

OriginalL'auteur dtb

Vous pourriez faire ceci:

public class GeoCoordinates {
  public decimal Latitude { get; set; }
  public decimal Longitude { get; set; }

  public GeoCoordinates( string latLongPair ) {
    decimal lat, lng;
    var parts = latLongPair.Split( new[] { ',' } );
    if( decimal.TryParse( parts[0], out lat ) &&
      decimal.TryParse( parts[1], out lng ) ) {
      Latitude = lat;
      Longitude = lng;
    } else {
      //you could set some kind of "ParseFailed" or "Invalid" property here
    }
  }
}

Ensuite, vous pouvez créer une collection de GeoCoordinate classes ainsi:

var coords = segment.Split( new[] {';'} ).Select( x => new GeoCoordinates( x ) );

Vous me battre pour elle! 🙂
Heh...StackOverflow peut être tout à fait la course, ne peut-il pas?

OriginalL'auteur Ethan Brown

Ici est un " peu " de nice extrait montrant:

précompilés regexen
LINQ to anonyme de type projection
Culture-connaissance (corriger) le numéro de l'analyse et de l'impression

Vous voulez extraire un code (par exemple, le nombre d'analyse) dans la vraie vie.

Voir en direct sur Ideone.com.

using System;
using System.Linq;
using System.Text.RegularExpressions;
using System.Globalization;

namespace SODemo
{
    class MainClass
    {
        private static readonly CultureInfo CInfo = CultureInfo.CreateSpecificCulture("en-US");

        public static void Main (string[] args)
        {
            string segment = "51.54398, -0.27585;51.55175, -0.29631;51.56233, -0.30369;51.57035, -0.30856;51.58157, -0.31672;51.59233, -0.3354";

            var re = new Regex(@"\s*(?<lat>[-+]?[0-9.]+),\s*(?<lon>[-+]?[0-9.]+)\s*;", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);

            var locations = re.Matches(segment).Cast<Match>().Select(m => new 
            {
                Lat  = decimal.Parse(m.Groups["lat"].Value, CInfo),
                Long = decimal.Parse(m.Groups["lon"].Value, CInfo),
            });

            foreach (var l in locations)
                Console.WriteLine(l);
        }
    }
}

De sortie:

{ Lat = 51,54398, Long = -0,27585 }
{ Lat = 51,55175, Long = -0,29631 }
{ Lat = 51,56233, Long = -0,30369 }
{ Lat = 51,57035, Long = -0,30856 }
{ Lat = 51,58157, Long = -0,31672 }

OriginalL'auteur sehe

2

Est-il une nécessité pour vous d'utiliser LINQ? Vous pouvez tout faire avec la norme de chaîne de fractionnement de la fonctionnalité:
```
string[] pairsOfCoords = segment.Split(';');
List<CoordsObject> listOfCoords = new List<CoordsObject>();
foreach (string str in pairsOfCoords)
{
  string[] coords = str.Split(',');
  CoordsObject obj = new CoordsObject(coords[0], coords[1]);
  listOfCoords.Add(obj);
}
```
Oui, mais, regardez comment beaucoup plus propre c'est avec linq. 🙂
Eh bien, je suppose que c'est subjectif. Cela semble assez simple et propre pour moi.

OriginalL'auteur Adam V

Je pourrais ajouter un peu plus. Grâce à dtb pour le début, upvoted. Si vous cassez votre analyse de la fonction, vous pouvez plus proprement gérer les conditions d'erreur, tels que le mauvais nombre d'éléments de votre tableau, ou des choses qui ne pas analyser à une décimale.

Coordinate[] result = segment
.Split(';')
.Select(s => s.Split(','))
.Select(BuildCoordinate)
.ToArray();

Coordrinate BuildCoordinate(string[] coords)
{
    if(coords.Length != 2)
        return null;

    return new Coordinate(double.Parse(a[0].Trim(), double.Parse(a[1]);
}

OriginalL'auteur SouthShoreAK

Vous devez vous connecter pour publier un commentaire.