Core/Castle.Core/Resource/AssemblyResource.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Core.Resource
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Reflection;
  20
  21         public class AssemblyResource : AbstractStreamResource
  22         {
  23                 private readonly Stream stream;
  24                 private string assemblyName;
  25                 private string resourcePath;
  26                 private String basePath;
  27
  28                 public AssemblyResource(CustomUri resource)
  29                 {
  30                         stream = CreateResourceFromUri(resource, null);
  31                 }
  32
  33                 public AssemblyResource(CustomUri resource, String basePath)
  34                 {
  35                         stream = CreateResourceFromUri(resource, basePath);
  36                 }
  37
  38                 public AssemblyResource(String resource)
  39                 {
  40                         stream = CreateResourceFromPath(resource, basePath);
  41                 }
  42
  43                 protected override Stream Stream
  44                 {
  45                         get { return stream; }
  46                 }
  47
  48                 public override IResource CreateRelative(String resourceName)
  49                 {
  50                         throw new NotImplementedException();
  51                 }
  52
  53                 public override string ToString()
  54                 {
  55                         return String.Format("AssemblyResource: [{0}] [{1}]", assemblyName, resourcePath);
  56                 }
  57
  58                 private Stream CreateResourceFromPath(String resource, String path)
  59                 {
  60                         if (!resource.StartsWith("assembly" + CustomUri.SchemeDelimiter))
  61                         {
  62                                 resource = "assembly" + CustomUri.SchemeDelimiter + resource;
  63                         }
  64
  65                         return CreateResourceFromUri(new CustomUri(resource), path);
  66                 }
  67
  68                 private Stream CreateResourceFromUri(CustomUri resourcex, String basePath)
  69                 {
  70                         if (resourcex == null) throw new ArgumentNullException("resourcex");
  71
  72                         assemblyName = resourcex.Host;
  73                         resourcePath = ConvertToResourceName(assemblyName, resourcex.Path, basePath);
  74
  75                         Assembly assembly = ObtainAssembly(assemblyName);
  76
  77                         String[] names = assembly.GetManifestResourceNames();
  78
  79                         String nameFound = GetNameFound(names);
  80
  81                         if (nameFound == null)
  82                         {
  83                                 resourcePath = resourcex.Path.Replace('/', '.').Substring(1);
  84                                 nameFound = GetNameFound(names);
  85                         }
  86
  87                         if (nameFound == null)
  88                         {
  89                                 String message = String.Format("The assembly resource {0} could not be located", resourcePath);
  90                                 throw new ResourceException(message);
  91                         }
  92
  93                         this.basePath = ConvertToPath(resourcePath);
  94
  95                         return assembly.GetManifestResourceStream(nameFound);
  96                 }
  97
  98                 private string GetNameFound(string[] names)
  99                 {
 100                         string nameFound = null;
 101                         foreach(String name in names)
 102                         {
 103                                 if (String.Compare(resourcePath, name, true) == 0)
 104                                 {
 105                                         nameFound = name;
 106                                         break;
 107                                 }
 108                         }
 109                         return nameFound;
 110                 }
 111
 112                 private string ConvertToResourceName(String assemblyName, String resource, String basePath)
 113                 {
 114                         // TODO: use basePath for relative name construction
 115                         return String.Format("{0}{1}", assemblyName, resource.Replace('/', '.'));
 116                 }
 117
 118                 private string ConvertToPath(String resource)
 119                 {
 120                         string path = resource.Replace('.', '/');
 121                         if (path[0] != '/')
 122                         {
 123                                 path = string.Format("/{0}", path);
 124                         }
 125                         return path;
 126                 }
 127
 128                 private Assembly ObtainAssembly(String assemblyName)
 129                 {
 130                         try
 131                         {
 132                                 return Assembly.Load(assemblyName);
 133                         }
 134                         catch(Exception ex)
 135                         {
 136                                 String message = String.Format("The assembly {0} could not be loaded", assemblyName);
 137                                 throw new ResourceException(message, ex);
 138                         }
 139                 }
 140         }
 141 }