Pytanie Pobierz rozszerzenie pliku lub "HasExtension" typ bool z obiektu Uri C #


Szybkie pytanie:

Czy ktoś może wymyślić lepszy sposób niż RegEx lub ogólne wyszukiwanie tekstu, aby ustalić, czy obiekt Uri (nie ciąg URL) ma rozszerzenie pliku?

Wszelkie przemyślenia mile widziane. Przepraszamy, jeśli coś pominąłem w klasie .NET / Uri, która już to robi.


Nieco bardziej złożona koncepcja.


Przyjąłem odpowiedź craigtp; jednak w tym przypadku potrzebuję rozwiązania.

var hasExtension = Path.HasExtension(requestUri.AbsolutePath);

Do wszystkich, którzy mieli na to ochotę. Aby uzyskać pełną i wyczerpującą odpowiedź, trzeba oczywiście użyć słownika typów mime, aby wykonać dalszą kontrolę. Na przykład http: //example/this.is.sort.of.valid.but.not.a.mime.type zwróci "prawda" Path.HasExtensionjednak w tym, czego potrzebuję, nigdy nie będę miał tego typu ścieżki.


21
2017-10-24 10:38


pochodzenie


Nie jestem pewien, czy będziesz w stanie odróżnić te dwie ostatnie sprawy od siebie, chyba że masz listę "rozpoznanych" rozszerzeń. - Rawling
Zająłem się tym w mojej edycji - ale to dobra uwaga. - LiverpoolsNumber9
"Zaakceptowałem odpowiedź craigtp, jednak" hej @ LiverpoolsNumber9, należy to zmienić, podając własną odpowiedź w nowej odpowiedzi poniżej, a następnie oznaczyć ją jako odpowiedź (jest to, przy okazji, całkowicie akceptowalne na SO, nawet jeśli natychmiast masz własną odpowiedź). Nadal można przyznać inną odpowiedź, która pomogła, ale zaznaczona odpowiedź nie jest, jak widać, pełną odpowiedzią na pytanie, jak uzyskać to od Uri rodzaj. - Nicholas Petersen


Odpowiedzi:


Możesz użyć HasExtension metoda System.IO.Path klasa, aby określić, czy ciąg znaków Uri ma rozszerzenie.

Korzystając z AbsoluteUri własność Uri obiekt, możesz pobrać kompletny ciąg, który reprezentuje Uri. Przekazywanie tego ciągu do klas Path HasExtension metoda poprawnie zwróci wartość logiczną wskazującą, czy Uri zawiera rozszerzenie pliku.

Skopiuj i wklej następujący kod do prostej aplikacji konsoli, aby przetestować to. Tylko myUri3 i myUrl4 return True, co również pokazuje, że HasExtension metoda może poprawnie radzić sobie z dodatkowymi znakami (np. Querystrings) po nazwie pliku (i rozszerzeniu).

using System;
using System.IO;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri myURI1 = new Uri(@"http://www.somesite.com/");
            Uri myURI2 = new Uri(@"http://www.somesite.com/filenoext");
            Uri myURI3 = new Uri(@"http://www.somesite.com/filewithext.jpg");
            Uri myURI4 = new Uri(@"http://www.somesite.com/filewithext.jpg?q=randomquerystring");

            Console.WriteLine("Does myURI1 have an extension: " + Path.HasExtension(myURI1.AbsoluteUri));
            Console.WriteLine("Does myURI2 have an extension: " + Path.HasExtension(myURI2.AbsoluteUri));
            Console.WriteLine("Does myURI3 have an extension: " + Path.HasExtension(myURI3.AbsoluteUri));
            Console.WriteLine("Does myURI4 have an extension: " + Path.HasExtension(myURI4.AbsoluteUri));

            Console.ReadLine();
        }
    }
}

EDYTOWAĆ: 

W oparciu o edycję pytania pytającego o określenie, czy rozszerzenie jest ważny Rozszerzenie, pobudziłem trochę nowego kodu poniżej (skopiuj i wklej do aplikacji konsoli):

using System;
using System.IO;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri myUri1 = new Uri("http://www.somesite.com/folder/file.jpg?q=randomquery.string");
            string path1 = String.Format("{0}{1}{2}{3}", myUri1.Scheme, Uri.SchemeDelimiter, myUri1.Authority, myUri1.AbsolutePath);
            string extension1 = Path.GetExtension(path1);
            Console.WriteLine("Extension of myUri1: " + extension1);

            Uri myUri2 = new Uri("http://www.somesite.com/folder/?q=randomquerystring");
            string path2 = String.Format("{0}{1}{2}{3}", myUri2.Scheme, Uri.SchemeDelimiter, myUri2.Authority, myUri2.AbsolutePath);
            string extension2 = Path.GetExtension(path2);
            Console.WriteLine("Extension of myUri1: " + extension2);

            Console.ReadLine();
        }
    }
}

Ten nowy kod dekonstruuje teraz wszystkie części składowe obiektu Uri (tj. Scheme - the http część itp.) i konkretnie usuwa dowolna część tekstu Uri. Pozwala to obejść potencjalny problem, jak zauważyliśmy Adriano w komentarzu do tej odpowiedzi, że querystring może zawierać znak kropki (co potencjalnie zepsuć HasExtension metoda).

Po usunięciu Uri możemy teraz poprawnie określić oba łańcuchy Uri ma rozszerzenie, a także co to rozszerzenie jest.

Od tego momentu chodzi tylko o dopasowanie tego rozszerzenia do listy znanych poprawnych rozszerzeń. Ta część jest czymś, czego struktura .NET nigdy ci nie dała każdy rozszerzenie pliku jest potencjalnie ważne (każda aplikacja może uzupełnić własne rozszerzenie pliku, jeśli tego chce!)


20
2017-10-24 10:59



-1 AbsoluteUri nie usuwa Query i Fragment z URI. - Adriano Repetti
@Adriano - W pierwotnym pytaniu PO (z pytaniem tylko czy Uri ma rozszerzenie, nie co to jest), nie musi! - CraigTP
Cóż, URI mogą mają część zapytania i fragmentu (i kropka może znajdować się w części zapytania, nie w ostatnim segmencie) - Adriano Repetti
@Adriano Nawet jeśli tak, wciąż mają rozszerzenie. Czy możesz podać przykład, w którym jego metoda zawodzi? - Paolo Moretti
Rozumiem, może powinien użyć Uri.AbsolutePath zamiast Uri.AbsoluteUri - Paolo Moretti


Właściwość Uri.IsFile zasugerowana przez innych nie działa.

Od dokumentów

The IsFile property is true when the Scheme property equals UriSchemeFile.

file://server/filename.ext"

http://msdn.microsoft.com/en-us/library/system.uri.isfile.aspx

Co można zrobić, to uzyskać AbsolutePath identyfikatora URI (który odpowiada na przykład / contact lub /images/logo.png), a następnie użyć klasy FileInfo, aby sprawdzić / uzyskać rozszerzenie.

var uris = new List<Uri>()
{
  new Uri("http://mysite.com/contact"),
  new Uri("http://mysite.com/images/logo.png"),
  new Uri("http://mysite.com/images/logo.png?query=value"),
};

foreach (var u in uris)
{
  var fi = new FileInfo(u.AbsolutePath);
  var ext = fi.Extension;
  if (!string.IsNullOrWhiteSpace(ext))
  {
    Console.WriteLine(ext);
  }
}

Prawdopodobnie musisz sprawdzić listę obsługiwanych rozszerzeń, aby obsłużyć bardziej skomplikowane sprawy (contact.is.sortof.valid i contact.is.sortof.valid.png)

Testy:

"http://mysite.com/contact"                             //no ext
"http://mysite.com/contact?query=value"                 //no ext
"http://mysite.com/contact?query=value.value"           //no ext
"http://mysite.com/contact/"                            //no ext
"http://mysite.com/images/logo.png"                     //.png
"http://mysite.com/images/logo.png?query=value"         //.png
"http://mysite.com/images/logo.png?query=value.value"   //.png
"http://mysite.com/contact.is.sortof.valid"             //.valid
"http://mysite:123/contact.is.sortof.valid"              //.valid

7
2017-10-24 10:55



Być może OP mógłby połączyć twoją odpowiedź z tą (stackoverflow.com/questions/3937958/...), aby wygenerować listę obsługiwanych rozszerzeń na podstawie konfiguracji typu MIME. - Jamie Keeling
Cześć - dziękuję za to @wdavo - działa, ale użyłem "Path.HasExtension", które skutecznie robi to samo. - LiverpoolsNumber9
Możesz także użyć Path.GetExtension(request.Url.AbsolutePath) zamiast tego FileInfo klasa - Chris Marisic


tutaj jest moje rozwiązanie, aby to dobrze;)

        var inputString = ("http://ask.com/pic.JPG http://aSk.com/pIc.JPG "
        + "http://ask.com/pic.jpg "
        + "http://yoursite.com/contact "
        + "http://yoursite.com/contact?query=value "
        + "http://yoursite.com/contact?query=value.value "
        + "http://yoursite.com/contact/ "
        + "http://yoursite.com/images/Logo.pnG "
        + "http://yoursite.com/images/lOgo.pNg?query=value "
        + "http://yoursite.com/images/logo.png?query=value.value "
        + "http://yoursite.com/contact.is.sortof.valid "
        + "http://mysite:123/contact.is.sortof.valid").Split(' ');

        var restultString = "";

        foreach (var is1 in inputString)
        {
            restultString += (!string.IsNullOrEmpty(restultString) ? " " : "") +
                  (Path.HasExtension(is1) ? Path.ChangeExtension(is1, Path.GetExtension(is1).ToLower()) : is1);
        }

0
2017-11-22 01:10