forked from ExtCore/ExtCore
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathCompositeFileProvider.cs
More file actions
182 lines (154 loc) · 4.03 KB
/
CompositeFileProvider.cs
File metadata and controls
182 lines (154 loc) · 4.03 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
// Copyright © 2015 Dmitry Sikorsky. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Primitives;
namespace ExtCore.Mvc
{
/// <summary>
/// Implements the <see cref="IFileProvider">IFileProvider</see> interface and represents composite file provider
/// that is built from the set of other file providers like <see cref="PhysicalFileProvider">PhysicalFileProvider</see>,
/// <see cref="EmbeddedFileProvider">EmbeddedFileProvider</see> etc. It is used to make it possible to resolve
/// files that are located in a file system, assemblies etc.
/// </summary>
public class CompositeFileProvider : IFileProvider
{
private readonly IEnumerable<IFileProvider> fileProviders;
/// <summary>
/// Initializes a new instance of the <see cref="CompositeFileProvider">CompositeFileProvider</see> class.
/// </summary>
/// <param name="fileProviders">The set of the file providers to look for the files in.</param>
public CompositeFileProvider(IEnumerable<IFileProvider> fileProviders)
{
this.fileProviders = fileProviders;
}
public IDirectoryContents GetDirectoryContents(string subpath)
{
foreach (IFileProvider fileProvider in this.fileProviders)
{
IDirectoryContents directoryContents = fileProvider.GetDirectoryContents(subpath);
if (directoryContents != null && directoryContents.Exists)
return directoryContents;
}
return new NonexistentDirectoryContents();
}
public IFileInfo GetFileInfo(string subpath)
{
foreach (IFileProvider fileProvider in this.fileProviders)
{
IFileInfo fileInfo = fileProvider.GetFileInfo(subpath);
if (fileInfo != null && fileInfo.Exists)
return fileInfo;
}
return new NonexistentFileInfo(subpath);
}
public IChangeToken Watch(string filter)
{
foreach (IFileProvider fileProvider in this.fileProviders)
{
IChangeToken changeToken = fileProvider.Watch(filter);
if (changeToken != null)
return changeToken;
}
return NonexistentChangeToken.Singleton;
}
}
internal class NonexistentDirectoryContents : IDirectoryContents
{
public bool Exists
{
get
{
return false;
}
}
public IEnumerator<IFileInfo> GetEnumerator()
{
return Enumerable.Empty<IFileInfo>().GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
}
internal class NonexistentFileInfo : IFileInfo
{
private readonly string name;
public NonexistentFileInfo(string name)
{
this.name = name;
}
public bool Exists
{
get
{
return false;
}
}
public bool IsDirectory
{
get
{
return false;
}
}
public DateTimeOffset LastModified
{
get
{
return DateTimeOffset.MinValue;
}
}
public long Length
{
get
{
return -1;
}
}
public string Name
{
get
{
return this.name;
}
}
public string PhysicalPath
{
get
{
return null;
}
}
public Stream CreateReadStream()
{
throw new FileNotFoundException(this.name);
}
}
internal class NonexistentChangeToken : IChangeToken
{
public static NonexistentChangeToken Singleton { get; } = new NonexistentChangeToken();
public bool ActiveChangeCallbacks
{
get
{
throw new NotImplementedException();
}
}
public bool HasChanged
{
get
{
throw new NotImplementedException();
}
}
public IDisposable RegisterChangeCallback(Action<object> callback, object state)
{
throw new NotImplementedException();
}
}
}