Newsgroup: it.comp.lang.visual-basic
Titolo: [.NET][C#][OT] Funzione Split

Scusate l'OT. La prossima volta voterò per il NG su C#... :-)
Vorrei usare la funzione Split di Visual Basic in C#. Devo scriverla io o è
già implementata nel framework .NET?
String.Split() non va bene perché accetta solo caratteri come separatori, e
non stringhe.
Grazie,
Ignazio

 non stringhe.
Vero, io però che sono pigro l'ho risolta così:
// Voglio usare ** e -> come separatori:
string s = "asterischi**e**freccie->ci->separano";
string[] a = s.Replace("**", "|").Replace("->", "|").Split('|');
Ciao
--
using System.Gtk.Forms = "
http://www.neodatatype.net/windowsforms/sgf.aspx
"
mathParser = "
http://www.neodatatype.net
"
sitoComune = "
http://www.it-lang-vb.net
"

 string[] a = s.Replace("**", "|").Replace("->", "|").Split('|');
Buona idea! Grazie!
Ignazio

 string[] a = s.Replace("**", "|").Replace("->", "|").Split('|');
L'ho scritta cosě: che ne pensi?
public static string[] Split (string sIn, string sDelim, int nLimit)
{
    int nC = 0, nPos, nOldPos, nDelimLen;
    if (sDelim.Length == 0)
        return null;
    nPos = sIn.IndexOf(sDelim);
    while (nPos != -1) {
        nC++;
        nPos = sIn.IndexOf(sDelim, nPos + 1);
    }
    string[] sOut = new string[nC + 1];
    nDelimLen = sDelim.Length;
    nOldPos = 0;
    nPos = sIn.IndexOf(sDelim);
    nC = 0;
    while (nPos != -1 && !(nLimit != -1 && nC >= nLimit - 1)) {
        sOut[nC] = sIn.Substring(nOldPos, nPos - nOldPos);
        nC++;
        nOldPos = nPos + nDelimLen;
        nPos = sIn.IndexOf(sDelim, nOldPos);
    }
    sOut[nC] = sIn.Substring(nOldPos, sIn.Length - nOldPos);
    return sOut;
}
public static string[] Split (string sIn, string sDelim)
{
    return Split(sIn, sDelim, -1);
}
Ignazio

 L'ho scritta così: che ne pensi?
Ho trovato la soluzione: il metodo statico
System.Text.RegularExpressions.Regex.Split(string, string)
Spero possa essere utile... Anche per il thread "Senza compatibilità":
questo metodo dovrebbe essere più portabile della funzione Split...
Ignazio

 questo metodo dovrebbe essere più portabile della funzione Split...
Mi piacerebbe conoscere le prestazioni delle varie soluzioni.
Le RegEx non sono certo famose per la loro leggerezza e velocità :)


 Mi piacerebbe conoscere le prestazioni delle varie soluzioni.
Detto fatto! :-)
Il codice č questo:
using System;
class MainClass
{
 public static string[] MioSplit (string sIn, string sDelim, int nLimit)
 {
  int nC = 0, nPos, nOldPos, nDelimLen;
  if (sDelim.Length == 0)
   return null;
  nPos = sIn.IndexOf(sDelim);
  while (nPos != -1) {
   nC++;
   nPos = sIn.IndexOf(sDelim, nPos + 1);
  }
  string[] sOut = new string[nC + 1];
  nDelimLen = sDelim.Length;
  nOldPos = 0;
  nPos = sIn.IndexOf(sDelim);
  nC = 0;
  while (nPos != -1 && !(nLimit != -1 && nC >= nLimit - 1)) {
   sOut[nC] = sIn.Substring(nOldPos, nPos - nOldPos);
   nC++;
   nOldPos = nPos + nDelimLen;
   nPos = sIn.IndexOf(sDelim, nOldPos);
  }
  sOut[nC] = sIn.Substring(nOldPos, sIn.Length - nOldPos);
  return sOut;
 }
 public static void Main(string[] args)
 {
  string input;
  string[] Parole;
  const string sep = "\x000D\x000A";
  const int NumeroProve = 100;
  const int NumeroStringhe = 10000;
  long TickInizio;
  Console.WriteLine ("Costruzione della stringa...");
  System.Text.StringBuilder sb = new System.Text.StringBuilder();
  for (int i = 0; i < NumeroStringhe; i++)
   sb.Append ("Prova" + sep);
  input = sb.ToString();
  Console.WriteLine ("Test di System.String.Replace.Split ...");
  TickInizio = DateTime.Now.Ticks;
  for (int i = 0; i < NumeroProve; i++)
   Parole = input.Replace(sep, "|").Split('|');
  Console.WriteLine ("System.String.Replace.Split: " +
((DateTime.Now.Ticks - TickInizio) * 1E-7 / NumeroProve *
1000).ToString("0.00000") + " millisecondi.");
  Console.WriteLine ("Test di System.Text.RegularExpressions.Regex.Split
...");
  TickInizio = DateTime.Now.Ticks;
  for (int i = 0; i < NumeroProve; i++)
   Parole = System.Text.RegularExpressions.Regex.Split(input, sep);
  Console.WriteLine ("System.Text.RegularExpressions.Regex.Split: " +
((DateTime.Now.Ticks - TickInizio) * 1E-7 / NumeroProve *
1000).ToString("0.00000") + " millisecondi.");
  Console.WriteLine ("Test di MioSplit ...");
  TickInizio = DateTime.Now.Ticks;
  for (int i = 0; i < NumeroProve; i++)
   Parole = MioSplit(input, sep, -1);
  Console.WriteLine ("MioSplit: " + ((DateTime.Now.Ticks - TickInizio) *
1E-7 / NumeroProve * 1000).ToString("0.00000") + " millisecondi.");
 }
}
Risultati:
NumeroStringhe | System.String.Replace.Split |
System.Text.RegularExpressions.Regex.Split | MioSplit
10 | 0,006 | 0,033 | 0,014
100 | 0,05 | 0,24 | 0,12
1.000 | 0,61 | 2,66 | 1,29
10.000 | 6,60 | 37,25 | 13,01
Come vedi, la soluzione proposta da te č la migliore in termini di
prestazioni, il doppio piů veloce di quella scritta da me, che a sua volta č
il doppio piů veloce di quella in Regex.
Ignazio