Obtenir toutes les valeurs D'une collection NameValueCollection à une chaîne

string values = string.Join(",", collection.AllKeys.Select(key => collection[key]));

string values = 
    string.Join(",", FormValues.AllKeys.SelectMany(key => FormValues.GetValues(key)));

Edit: les autres réponses peuvent être ou non ce que vous voulez. Ils semblent plus simples, mais les résultats pourraient ne pas être ce que vous recherchez dans toutes les circonstances, mais encore une fois, ils pourraient être (votre kilométrage peut varier).

notez que a NameValueCollection n'est pas un mappage 1:1 comme un dictionnaire. Vous pouvez ajouter plusieurs valeurs pour la même clé, c'est pourquoi une fonction comme .GetValues(key) retourne un tableau, pas une seule chaîne.

Si vous avez une collection de lorsque vous avez ajouté

 collection.Add("Alpha", "1");
 collection.Add("Alpha", "2");
 collection.Add("Beta", "3");

Récupérer collection["Alpha"] les rendements "1,2". Récupération collection.GetValues("Alpha") les rendements { "1", "2" }. Maintenant, il se trouve que vous utilisez une virgule pour réunir vos valeurs en une seule chaîne, donc cette disparité est cachée. Cependant, si vous vous joignez sur une autre valeur, comme un point d'exclamation, les résultats des autres réponses seraient

"1,2!3"

Et le code ici

"1!2!3"

utilisez l'extrait qui démontre le le comportement que vous préférez.

suit crée une chaîne de caractères à partir de la liste des paramètres de L'URL.

string.Join(", ", 
            Request.QueryString
                   .AllKeys
                   .Select(key => key + ": " + Request.QueryString[key])
      .ToArray())

j'.e

page.aspx?id=75&page=3&size=7&user=mamaci

id: 75, page: 3, size: 7, user: mamaci

dans les cas où vous avez analysé la chaîne de requête avec le système.Web.HttpUtility.ParseQueryString(... vous pouvez simplement utiliser ToString () et vous n'avez pas à réinventer la roue.

même si le résultat est NameValueCollection, le type sous-jacent est HttpValueCollection qui a le ToString() override nécessaire pour reconstruire une chaîne de requête.

J'utilise Azure DocumentDB comme mécanisme de journalisation, donc j'écris un objet dynamique, mais vous obtenez l'essentiel...

public class LogErrorAttribute : HandleErrorAttribute
{
    public override void OnException(ExceptionContext filterContext)
    {
        int responseCode = new int();

        // Has the exception been handled.  Also, are custom errors enabled
        if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled)
            return;

        // Check if custom exception, if so get response code
        if (filterContext.Exception is CustomException)
            responseCode = (int)((CustomException)filterContext.Exception).Code;

        // Log exception
        string id = Logging.Write(LogType.Error, new
        {
            ResponseCode = responseCode,
            Exception = new
            {
                Message = filterContext.Exception.Message,
                Data = filterContext.Exception.Data,
                Source = filterContext.Exception.Source,
                StackTrace = filterContext.Exception.StackTrace,
                InnerException = filterContext.Exception.InnerException != null ? new
                {
                    Message = filterContext.Exception.InnerException.Message,
                    Data = filterContext.Exception.InnerException.Data,
                    Source = filterContext.Exception.InnerException.Source,
                    StackTrace = filterContext.Exception.InnerException.StackTrace
                } : null
            },
            Context = filterContext.Controller != null ? new
            { 
                RouteData = filterContext.Controller.ControllerContext.RouteData,
                QueryString = filterContext.Controller.ControllerContext.HttpContext.Request.Url.Query,
                FormParams = filterContext.Controller.ControllerContext.HttpContext.Request.Form != null ? string.Join(";#", filterContext.Controller.ControllerContext.HttpContext.Request.Form.AllKeys.Select(key => key + ":" + filterContext.Controller.ControllerContext.HttpContext.Request.Form[key])) : string.Empty,
                Model = (filterContext.Controller is Controller) ? ((Controller)filterContext.Controller).ModelState : null,
                ViewBag = filterContext.Controller.ViewBag,
                ViewData = filterContext.Controller.ViewData
            } : null,
            ActionResult = filterContext.Result != null ? filterContext.Result : null,
            Referrer = filterContext.HttpContext.Request.UrlReferrer != null ? filterContext.HttpContext.Request.UrlReferrer : null
        }).Result;

        // Mark exception as handled and return
        filterContext.ExceptionHandled = true;

        // Test for Ajax call
        if (IsAjax(filterContext))
        {
            // Construct appropriate Json response
            filterContext.Result = new JsonResult()
            {
                Data = new
                {
                    code = responseCode,
                    id = id,
                    message = filterContext.Exception.Message
                },
                JsonRequestBehavior = JsonRequestBehavior.AllowGet
            };

        }
        else
        {
            var result = new ViewResult();
            result.ViewName = "_CustomError";
            result.ViewBag.CorrelationId = id;
            filterContext.Result = result;
        }
    }

    /// <summary>
    /// Determine if the request is from an Ajax call
    /// </summary>
    /// <param name="filterContext">The request context</param>
    /// <returns>True or false for an Ajax call</returns>
    private bool IsAjax(ExceptionContext filterContext)
    {
        return filterContext.HttpContext.Request.Headers["X-Requested-With"] == "XMLHttpRequest";
    }
}

j'ai un CustomException où je vérifie un code de réponse d'application.

En outre, je prends le querystring, les données de forme, et le modèle de sorte que je puisse voir les valeurs passées avant et après le liant de modèle.

si son et L'appel Ajax, je renvoie une réponse formatée par Json. Sinon, je renvoie une erreur personnalisée page.

List<string> values = new List<string>();
values.AddRange(all.AllKeys.SelectMany(all.GetValues).Where(getValues => getValues != null));
string Values = string.Join(",", values.ToArray());

Vous pouvez essayer quelque chose comme ci-dessus.