C# regex - seleziona i nomi delle proprietà di classe, il nome dei metodi ei campi dal file di classe (.cs)

Question

Voglio corrispondere (selezionare dal file di classe) methodname, nome proprietà e nome campi.

Questo è esempio di classe:

class Perl 
{ 
    string _name; 
    public string Name { get; set; } 
    public Perl() 
    { 
    // Assign this._name 
    this._name = "Perl"; 
    // Assign _name 
    _name = "Sam"; 

    // The two forms reference the same field. 
    Console.WriteLine(this._name); 
    Console.WriteLine(_name); 
    } 
    public static string doSomething(string test) 
    { 
     bla test; 
    } 
} 

Ho codice per i metodi:

(?:public|private|protected)([\s\w]*)\s+(\w+)\s*\(\s*(?:\w+\s+(\w+)\s*,?\s*)+\) 

e ho avuto domande:

• questo codice regex sopra ottiene tutti i metodi e lo funziona piuttosto bene ma anche io voglio che selezioni il nome del metodo ma senza parametri e accessori. Così dalla classe exaplmce usando il mio risultato il codice sarà: Perl pubblico() e doSomething public static (test string) ma voglio quel tipo di risultato: Perl() e doSomething(). Quindi - il mio codice corrisponde bene ma voglio che i risultati vengano visualizzati proprio come ho scritto io nella frase precedente.
• come selezionare le proprietà? con risultato visualizzato: tipo e proprietà nome. Quindi dal risultato della classe di estrazione sarà: stringa Nome
• come selezionare i campi con risultato: tipo nome_campo. Nel caso in cui fuori che sarà: stringa _name

Answer 1

Utilizzare questa Regex

per i metodi

(?:public\s|private\s|protected\s|internal\s)?[\s\w]*\s+(?<methodName>\w+)\s*\(\s*(?:(ref\s|/in\s|out\s)?\s*(?<parameterType>\w+)\s+(?<parameter>\w+)\s*,?\s*)+\) 

e ottenere gruppi denominati methodName e parameterType e parameter.

e per i campi:

(?:public\s|private\s|protected\s)\s*(?:readonly\s+)?(?<type>\w+)\s+(?<name>\w+) 

e ottenere gruppi denominati type e name.

ad esempio il codice per i metodi può essere come questo:

var inputString0 = "public void test(string name, out int value)\r\nvoid test(string name, int value)"; 
foreach (Match match in Regex.Matches(inputString0, @"(?:public\s|private\s|protected\s)?[\s\w]*\s+(?<methodName>\w+)\s*\(\s*(?:(ref\s|/in\s|out\s)?\s*(?<parameterType>[\w\?\[\]]+)\s+(?<parameter>\w+)\s*,?\s*)+\)")) 
{ 
    var methodName = match.Groups["methodName"].Value; 
    var typeParameterPair = new Dictionary<string, string>(); 
    int i = 0; 
    foreach (var capture in match.Groups["parameterType"].Captures) 
    { 
     typeParameterPair.Add(match.Groups["parameterType"].Captures[i].Value, match.Groups["parameter"].Captures[i].Value); 
     i++; 
    } 
} 

È possibile utilizzare Irony - .NET Language Implementation Kit da CodePlex troppo.

Answer 2

Come indicato nei commenti alla tua risposta, molto più affidabile metodo è quello di compilare i file Cs e quindi utilizzare la riflessione per interrogare tipi per i membri a cui è interessato che coinvolgerà la seguente:.

1. Usa Compilatore C# (csc.exe) per compilare i tuoi file. MSDN contiene examples and hints utile. È possibile farlo manualmente o, se si desidera automatizzare l'intera operazione, è possibile eseguire csc.exe in modo programmatico con Process class.
2. Utilizzare il metodo Assembly.LoadFile() per caricare l'assieme risultante.
3. È ora possibile utilizzare la riflessione su get types dal gruppo e interrogate.

EDIT: In alternativa Csc.exe, si potrebbe usare CodeDOM - c'è un example che contiene tutto ciò che serve.

Answer 3

Un linguaggio come C# accetta troppe variazioni nella sintassi delle istruzioni da analizzare solo con le espressioni regolari. Oltre alle espressioni regolari, è necessario un parser di grammatica contestuale.

Vorrei dare una prova a Roslyn: È un compilatore C# i cui interni sono accessibili dal codice. Chiedi a Roslyn di analizzare il codice e interrogarlo su qualunque informazione tu abbia bisogno.

Answer 4

Suggerisco di guardare lo spazio dei nomi Microsoft.VisualStudio.CSharp.Services.Language e altre funzionalità di Visual Studio Extensibility. Ciò eliminerebbe la necessità di compilare.