web-dev-qa-db-fra.com

Interpolation dynamique de chaînes

Est-ce que quelqu'un peut m'aider avec ça?

Sortie requise: "Todo job for admin"

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(ReplaceMacro("{job.Name} job for admin", new Job { Id = 1, Name = "Todo", Description="Nothing" }));
        Console.ReadLine();
    }

    static string ReplaceMacro(string value, Job job)
    {
        return value; //Output should be "Todo job for admin"
    }
}

class Job
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
}
c#string-interpolation
21
Jitendra Tiwari

Deux suggestions:

DataBinder.Eval 

string ReplaceMacro(string value, Job job)
{
    return Regex.Replace(value, @"{(?<exp>[^}]+)}", match => {
        return (System.Web.UI.DataBinder.Eval(new { Job = job }, match.Groups["exp"].Value) ?? "").ToString();
    });
}

Linq.Expression

Utilisez la classe Dynamic Query fournie dans MSDN LINQSamples :

string ReplaceMacro(string value, Job job)
{
    return Regex.Replace(value, @"{(?<exp>[^}]+)}", match => {
        var p = Expression.Parameter(typeof(Job), "job");
        var e = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p }, null, match.Groups["exp"].Value);
        return (e.Compile().DynamicInvoke(job) ?? "").ToString();
    });
}

À mon avis, l'expression Linq est plus puissante, donc si vous faites confiance à la chaîne d'entrée, vous pouvez faire des choses plus intéressantes, à savoir:

value = "{job.Name.ToUpper()} job for admin"
return = "TODO job for admin"
27
Dan

Vous ne pouvez pas utiliser l'interpolation de chaînes de cette façon. Mais vous pouvez toujours utiliser la méthode pré-C # 6 pour le faire en utilisant string.Format:

static void Main(string[] args)
{
    Console.WriteLine(ReplaceMacro("{0} job for admin", new Job { Id = 1, Name = "Todo", Description = "Nothing" }));
    Console.ReadLine();
}

static string ReplaceMacro(string value, Job job)
{
    return string.Format(value, job.Name);
}
8
Jonesopolis

Vous avez besoin d'un remplacement de format de chaîne nommé. Voir le post de Phil Haack d'il y a des années: http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-Edge-cases.aspx/ =

1
Chris Haines

Vous devez changer votre fonction pour:

static string ReplaceMacro(Job obj, Func<dynamic, string> function)
{
    return function(obj);
}

Et appelez ça:

Console.WriteLine(
    ReplaceMacro(
        new Job { Id = 1, Name = "Todo", Description = "Nothing" },
        x => $"{x.Name} job for admin"));
0
Alessandro D'Andria

Pas exactement mais avec un peu de tweek, j'ai créé une interpolation générique qui ne prend en charge que les champs/propriétés.

public static string Interpolate(this string template, params Expression<Func<object, string>>[] values)
        {
            string result = template;
            values.ToList().ForEach(x =>
            {
                MemberExpression member = x.Body as MemberExpression;
                string oldValue = $"{{{member.Member.Name}}}";
                string newValue = x.Compile().Invoke(null).ToString();
                result = result.Replace(oldValue, newValue);
            }

                );
            return result;
        }

Cas de test

 string jobStr = "{Name} job for admin";
        var d = new { Id = 1, Name = "Todo", Description = "Nothing" };
        var result = jobStr.Interpolate(x => d.Name);

Un autre

            string sourceString = "I wanted abc as {abc} and {dateTime} and {now}";
        var abc = "abcIsABC";
        var dateTime = DateTime.Now.Ticks.ToString();
        var now = DateTime.Now.ToString();
        string result = sourceString.Interpolate(x => abc, x => dateTime, x => now);
0
hungryMind

Cette solution générique Étendre la réponse fournie par @ Dan
Il peut être utilisé pour tout objet tapé.

installer System.Linq.Dynamic

     Install-Package System.Linq.Dynamic -Version 1.0.7 

    string ReplaceMacro(string value, object @object)
    {
        return Regex.Replace(value, @"{(.+?)}", 
        match => {
            var p = Expression.Parameter(@object.GetType(), @object.GetType().Name);                
            var e = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p }, null, match.Groups[1].Value);
            return (e.Compile().DynamicInvoke(@object) ?? "").ToString();
        });
    }

Voir une démonstration de travail pour un type de client

0
M.Hassan

Envelopper la chaîne dans une fonction ...

var f = x => $"Hi {x}";

f("Mum!");

//... Hi Mum!
0
Ian Warburton

Vous pouvez utiliser RazorEngine :

using RazorEngine;

class Program 
{
    static void Main(string[] args)
    {
        Console.WriteLine(ReplaceMacro("@Model.Name job for admin", new Job { Id = 1, Name = "Todo", Description="Nothing" }));
        Console.ReadLine();
    }

    static string ReplaceMacro(string value, Job job)
    {
        return Engine.Razor.RunCompile(value, "key", typeof(Job), job);
    }
}

Il prend même en charge les types anonymes et les appels de méthode:

string template = "Hello @Model.Name. Today is @Model.Date.ToString(\"MM/dd/yyyy\")";
var model = new { Name = "Matt", Date = DateTime.Now };

string result = Engine.Razor.RunCompile(template, "key", null, model);
0
Eugene Kulabuhov

La réponse de @ThePerplexedOne est meilleure, mais si vous avez vraiment besoin d'éviter l'interpolation de chaînes, alors

static string ReplaceMacro(string value, Job job)
{
    return value?.Replace("{job.Name}", job.Name); //Output should be "Todo job for admin"
}
0
tym32167